1260 lines
52 KiB
Python
1260 lines
52 KiB
Python
"""Evidence-backed Word/Excel artifacts, independent of the language model runtime."""
|
||
|
||
from datetime import datetime
|
||
from typing import Callable, cast
|
||
import json
|
||
from pathlib import Path
|
||
import re
|
||
import zipfile
|
||
from apps.admin_console.services.export_cache import (
|
||
compression,
|
||
export_lock,
|
||
fingerprint,
|
||
remember,
|
||
reusable,
|
||
)
|
||
from apps.admin_console.services.request_diagnostics import diagnostics_json
|
||
from apps.admin_console.services.task_lifecycle import guidance_details
|
||
from apps.admin_console.services import task_extensions
|
||
|
||
from docx import Document
|
||
from docx.enum.table import WD_CELL_VERTICAL_ALIGNMENT
|
||
from docx.oxml import OxmlElement
|
||
from docx.oxml.ns import qn
|
||
from docx.shared import Cm, Pt, RGBColor
|
||
from docx.styles.style import ParagraphStyle
|
||
from openpyxl import Workbook
|
||
from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
|
||
from openpyxl.utils import get_column_letter
|
||
|
||
from artemis.config import IMAGES_DIR, TRACES_PATH, WORKSPACE_ROOT
|
||
from apps.admin_console.database.repositories.session_repository import SessionRepository
|
||
from apps.admin_console.database.repositories.step_repository import StepRepository
|
||
from apps.admin_console.services.automation_store import store, identifier
|
||
from apps.admin_console.services.task_import import execution_title
|
||
from artemis.runtime.case_result import RESULT_LABELS, resolve_case_result
|
||
from apps.admin_console.services.case_review import reviewed_result
|
||
|
||
EXPORT_ROOT = WORKSPACE_ROOT / "artifacts" / "reports"
|
||
BATCH_ARCHIVE_SIGNATURE = "artemis-batch-layout-4"
|
||
|
||
|
||
def batch_archive_signature(batch_id: str | None = None) -> str:
|
||
signature = task_extensions.installation_signature()
|
||
if batch_id:
|
||
with store.connection() as conn:
|
||
changes = conn.execute(
|
||
"SELECT r.id,r.updated_at FROM automation_records r "
|
||
"JOIN automation_jobs j ON j.session_id=r.id "
|
||
"WHERE r.kind='task_extensions' AND j.batch_id=? ORDER BY r.id",
|
||
(batch_id,),
|
||
).fetchall()
|
||
if changes:
|
||
signature += ":" + fingerprint({"reviews": [tuple(row) for row in changes]})
|
||
return BATCH_ARCHIVE_SIGNATURE + (":" + signature if signature else "")
|
||
|
||
|
||
def extension_rows(report: dict) -> list[tuple[str, str, str]]:
|
||
return [
|
||
(section["name"], field["label"], field["value"])
|
||
for section in report.get("task_extensions", [])
|
||
for field in section["fields"]
|
||
]
|
||
|
||
|
||
STATUS = {
|
||
"completed": "执行完成",
|
||
"success": "执行完成",
|
||
"failed": "执行失败",
|
||
"cancelled": "已取消",
|
||
"interrupted": "执行中断",
|
||
"skipped": "已跳过",
|
||
"pending": "待执行",
|
||
"queued": "已排队",
|
||
"running": "执行中",
|
||
"task_paused": "等待指导",
|
||
"resuming": "等待设备恢复",
|
||
}
|
||
|
||
|
||
def archive_case_name(report: dict) -> str:
|
||
"""Keep case identifiers readable without allowing ZIP paths or Windows-invalid names."""
|
||
fallback = str(report.get("id") or "task")[:8]
|
||
candidate = str(report.get("case_id") or fallback).strip()
|
||
candidate = re.sub(r'[\\/:*?"<>|\x00-\x1f]', "_", candidate).strip(" .")
|
||
return candidate[:80] or fallback
|
||
|
||
|
||
def read_json(path: Path, fallback=None):
|
||
try:
|
||
return json.loads(path.read_text(encoding="utf-8"))
|
||
except (OSError, ValueError):
|
||
return fallback
|
||
|
||
|
||
def text(value) -> str:
|
||
raw = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, default=str)
|
||
return re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", "", raw)
|
||
|
||
|
||
def verdict(outcome: dict | None) -> str:
|
||
result = (outcome or {}).get("test_result")
|
||
if isinstance(result, dict) and result.get("status") in RESULT_LABELS:
|
||
if result["status"] == "inconclusive" and result.get("verification_skipped"):
|
||
return "未做 AI 判定"
|
||
label = RESULT_LABELS[result["status"]]
|
||
if result.get("source"):
|
||
label += "（人工确认）" if result["source"] == "human" else "（AI确认）"
|
||
return label
|
||
tests = (outcome or {}).get("tests") or {}
|
||
if tests.get("failed", 0):
|
||
return "验证失败"
|
||
if tests.get("unchecked", 0) or tests.get("inconclusive", 0):
|
||
return "验证不完整"
|
||
if tests.get("passed", 0):
|
||
return "验证通过"
|
||
return "未验证（执行完成不等于测试通过）"
|
||
|
||
|
||
def failure_reason(directory: Path, status: str, recorded: str | None) -> str:
|
||
def redact(value: str) -> str:
|
||
safe = text(value).strip()
|
||
safe = re.sub(r"sk-[A-Za-z0-9_-]{12,}", "[已隐藏密钥]", safe)
|
||
safe = re.sub(
|
||
r"(?i)(\b(?:authorization\s*:\s*bearer|bearer)\s+)[^\s,;]+",
|
||
r"\1[已隐藏密钥]",
|
||
safe,
|
||
)
|
||
safe = re.sub(
|
||
r"(?i)(\b(?:OPENAI_API_KEY|api[_-]?key)\s*[:=]\s*['\"]?)[^\s,'\";]+",
|
||
r"\1[已隐藏密钥]",
|
||
safe,
|
||
)
|
||
return safe[:500]
|
||
|
||
from apps.admin_console.services.automation_store import RECOVERY_ERRORS
|
||
|
||
if status == "completed" and recorded in RECOVERY_ERRORS:
|
||
return ""
|
||
if recorded:
|
||
return redact(recorded)
|
||
if status not in {"failed", "interrupted"}:
|
||
return ""
|
||
state = read_json(directory / "status.json", {})
|
||
if isinstance(state, dict) and state.get("error"):
|
||
return redact(state["error"])
|
||
result = read_json(directory / "result.json", {})
|
||
if isinstance(result, dict) and result.get("status") == "failed":
|
||
reason = result.get("error") or result.get("explanation")
|
||
if reason:
|
||
return redact(reason)
|
||
log_lines: list[str] = []
|
||
for name in ("stdout.log", "stderr.log"):
|
||
path = directory / name
|
||
try:
|
||
with path.open("rb") as stream:
|
||
stream.seek(0, 2)
|
||
stream.seek(max(0, stream.tell() - 131072))
|
||
log_lines.extend(stream.read().decode("utf-8", errors="replace").splitlines())
|
||
except OSError:
|
||
continue
|
||
for line in reversed(log_lines):
|
||
match = re.search(r"Error running automation:\s*(.+)", line)
|
||
if match:
|
||
return redact(match.group(1))
|
||
for line in reversed(log_lines):
|
||
stripped = line.strip()
|
||
if stripped.startswith(("⚠", "ℹ", "WARNING", "INFO", "DEBUG")):
|
||
continue
|
||
if any(
|
||
name in line
|
||
for name in (
|
||
"VisualStepSummarizer:",
|
||
"StepMemoryService:",
|
||
"Could not clean unowned screen wake locks",
|
||
)
|
||
):
|
||
continue
|
||
exception_line = re.fullmatch(
|
||
r"(?:[A-Za-z_]\w*\.)*[A-Za-z_]\w*(?:Error|Exception|Timeout):\s*.*",
|
||
stripped,
|
||
)
|
||
if exception_line and not re.search(r"(?i)(?:timeout|timed out|超时)", stripped):
|
||
return redact(stripped)
|
||
if re.search(
|
||
r"(?i)(?:\b(?:TimeoutError|APITimeoutError|ReadTimeout|ConnectTimeout)\s*:|"
|
||
r"(?:模型请求|任务执行|model request|task execution).{0,100}"
|
||
r"(?:超时|timed out|deadline exceeded))",
|
||
stripped,
|
||
):
|
||
return redact("模型请求或任务执行超时：" + stripped)
|
||
return "任务未完成，运行日志中没有可提取的具体异常；请查看执行步骤。"
|
||
|
||
|
||
def session_report(session_id: str, db_path=None) -> dict:
|
||
from apps.admin_console.services.exploration_evidence import exploration_metadata
|
||
from artemis.data_engine.evidence_sources import recorded_sources
|
||
|
||
identifier(session_id)
|
||
meta = store.job(session_id) or {}
|
||
batch = store.get("batch", meta["batch_id"]) if meta.get("batch_id") else None
|
||
repo = SessionRepository(db_path) if db_path else SessionRepository()
|
||
session = repo.get_session_by_id(session_id) or {}
|
||
if not session and not meta:
|
||
raise ValueError("任务记录不存在")
|
||
steps = StepRepository(db_path).get_session_steps(session_id) if session else []
|
||
steps = [s for s in steps if s.get("step_id") != "pre-planning"]
|
||
directory = TRACES_PATH / session_id
|
||
outcome = read_json(directory / "run_outcome.json", {})
|
||
content = ""
|
||
for name in ("output.md", "output.txt", "output.json"):
|
||
path = directory / "notes" / name
|
||
if path.is_file():
|
||
content = path.read_text(encoding="utf-8")
|
||
break
|
||
result = read_json(directory / "result.json")
|
||
if not content and result is not None:
|
||
content = text(result)
|
||
for step in reversed(steps):
|
||
action = step.get("action_taken") or {}
|
||
if isinstance(action, dict) and action.get("action") == "report_task_status":
|
||
args = action.get("args") or {}
|
||
if not content:
|
||
content = args.get("explanation") or ""
|
||
if not outcome:
|
||
outcome = {"task_status": args.get("status"), "tests": {}}
|
||
break
|
||
case = meta.get("case") or {}
|
||
status = meta.get("terminal_status") or meta.get("status") or session.get("status", "unknown")
|
||
error = failure_reason(directory, status, meta.get("error"))
|
||
ai_result = resolve_case_result(outcome, status, error)
|
||
test_result = reviewed_result(session_id, ai_result.model_dump() if ai_result else None, store)
|
||
if test_result:
|
||
outcome = {**outcome, "test_result": test_result}
|
||
verification = verdict(outcome)
|
||
if status in {"failed", "interrupted"} and verification.startswith("未验证"):
|
||
verification = "未验证（任务异常终止）"
|
||
if not content:
|
||
lines = ["本任务未保存独立输出正文。", f"当前有效判定：{verification}"]
|
||
if test_result:
|
||
if test_result.get("reason"):
|
||
lines.append(f"判定依据：{test_result['reason']}")
|
||
lines.extend(f"- {item}" for item in test_result.get("evidence") or [])
|
||
elif error:
|
||
lines.append(f"异常原因：{error}")
|
||
content = "\n\n".join(lines)
|
||
return {
|
||
"id": session_id,
|
||
**guidance_details(session_id, db_path=repo.db_path),
|
||
"exploration": exploration_metadata(session_id),
|
||
"name": execution_title(meta) or session.get("initial_goal", session_id)[:120],
|
||
"iteration": meta.get("iteration", 1),
|
||
"repeat_count": meta.get("repeat_count", 1),
|
||
"goal": case.get("goal") or session.get("initial_goal", ""),
|
||
"expected": case.get("expected", ""),
|
||
"status": status,
|
||
"verdict": verification,
|
||
"test_result": test_result,
|
||
"outcome": outcome,
|
||
"content": content,
|
||
"steps": steps,
|
||
"evidence_sources": recorded_sources(steps),
|
||
"start": session.get("start_time") or meta.get("started_at"),
|
||
"end": session.get("end_time") or meta.get("ended_at"),
|
||
"error": error,
|
||
"device": meta.get("device_serial") or text(session.get("device_info") or ""),
|
||
"tags": case.get("tags", ""),
|
||
"case_id": case.get("case_id", ""),
|
||
"category": case.get("category", ""),
|
||
"subcategory": case.get("subcategory", ""),
|
||
"preconditions": case.get("preconditions", ""),
|
||
"original_case": case.get("original_case"),
|
||
"task_config": case.get("task_config") or {},
|
||
"task_extensions": task_extensions.report_sections(session_id, store),
|
||
"runtime_diagnostics": read_json(directory / "runtime_diagnostics.json"),
|
||
"batch_diagnostics": (
|
||
{
|
||
key: batch.get(key)
|
||
for key in ("id", "status", "reason", "pause_source", "recovery_events")
|
||
}
|
||
if batch
|
||
else None
|
||
),
|
||
}
|
||
|
||
|
||
def time_text(value) -> str:
|
||
return (
|
||
datetime.fromtimestamp(float(value)).astimezone().strftime("%Y-%m-%d %H:%M:%S")
|
||
if value
|
||
else "—"
|
||
)
|
||
|
||
|
||
def lifecycle_text(value: dict) -> str:
|
||
labels = {
|
||
"total": "总历时",
|
||
"queued": "后台排队",
|
||
"resource_wait": "等待设备/资源",
|
||
"paused": "暂停与示范",
|
||
"execution": "执行与整理",
|
||
"final_review": "最终验收",
|
||
"report_export": "报告导出",
|
||
}
|
||
durations = value.get("durations") or {}
|
||
return (
|
||
"\n".join(
|
||
f"{label}：{round(durations[key], 1)} 秒"
|
||
if durations.get(key) is not None
|
||
else f"{label}：未记录"
|
||
for key, label in labels.items()
|
||
)
|
||
+ "\n执行含初始化与报告整理，不代表模型速度。"
|
||
)
|
||
|
||
|
||
def guidance_text(items: list[dict]) -> str:
|
||
labels = {
|
||
"pending": "已接收，等待读取",
|
||
"reading": "执行器正在读取",
|
||
"consumed": "执行器已读取",
|
||
"unapplied": "任务结束，未记录消费",
|
||
"unconfirmed": "任务结束，读取未确认",
|
||
}
|
||
return (
|
||
"\n".join(
|
||
f"{item['id']} · {labels.get(item['status'], '状态未知')} · 接收 {time_text(item.get('accepted_at') or item.get('timestamp'))}"
|
||
+ (f" · 读取 {time_text(item['consumed_at'])}" if item.get("consumed_at") else "")
|
||
for item in items
|
||
)
|
||
or "无指导记录"
|
||
)
|
||
|
||
|
||
def source_text(value: dict) -> str:
|
||
labels = {
|
||
"android": "安卓界面",
|
||
"computer": "电脑界面",
|
||
"api": "接口数据",
|
||
"terminal": "终端",
|
||
"file": "文件",
|
||
"other": "其他",
|
||
}
|
||
lines = []
|
||
for item in value.get("sources", []):
|
||
references = ", ".join(
|
||
" / ".join(
|
||
f"{key}={ref[key]}"
|
||
for key in ("step_id", "call_id", "source_id", "trace_id")
|
||
if ref.get(key)
|
||
)
|
||
or "编号未记录"
|
||
for ref in item.get("references", [])
|
||
)
|
||
variation = "（来源标签随步骤变化，详见原始步骤）" if item.get("label_varies") else ""
|
||
lines.append(
|
||
f"{labels.get(item['kind'], '其他')} · {item['label'] or item['target_id']}"
|
||
f"{variation} · {references}"
|
||
)
|
||
if value.get("sources_omitted"):
|
||
lines.append(f"另 {value['sources_omitted']} 个来源见原始步骤记录。")
|
||
lines.append(
|
||
f"未关联到单一来源的步骤：{value.get('unattributed_step_count', '未知')}。"
|
||
"窗口枚举等操作可能没有单一目标；此计数不表示截图丢失。"
|
||
)
|
||
lines.append(value.get("note") or "来源清单不代表断言已验证。")
|
||
return "\n".join(lines)
|
||
|
||
|
||
def metadata(report: dict) -> list[tuple]:
|
||
return [
|
||
("任务编号", report["id"]),
|
||
*(
|
||
(
|
||
[
|
||
("探索会话", report["exploration"]["id"]),
|
||
(
|
||
"探索关联",
|
||
"用例 v" + str(report["exploration"]["case_version"]) + " 复跑"
|
||
if report["exploration"]["kind"] == "validation"
|
||
else "探索执行（不等于独立复跑通过）",
|
||
),
|
||
]
|
||
)
|
||
if report.get("exploration")
|
||
else []
|
||
),
|
||
("用例编号", report.get("case_id") or "—"),
|
||
("检测项目", report.get("category") or "—"),
|
||
("测试子项", report.get("subcategory") or "—"),
|
||
("前置约束提取", report.get("preconditions") or "—"),
|
||
*(
|
||
[
|
||
("原始用例 · 预置条件", report["original_case"].get("preconditions") or "未填写"),
|
||
("原始用例 · 操作步骤", report["original_case"].get("steps") or "未填写"),
|
||
("原始用例 · 预期结果", report["original_case"].get("expected") or "未填写"),
|
||
]
|
||
if report.get("original_case") is not None
|
||
else []
|
||
),
|
||
("任务配置", config_text(report.get("task_config"))),
|
||
("任务目标", report["goal"]),
|
||
("预期结果", report["expected"] or "未指定"),
|
||
("执行状态", STATUS.get(report["status"], report["status"])),
|
||
("耗时分项", lifecycle_text(report.get("lifecycle") or {})),
|
||
("指导消费", guidance_text(report.get("instructions") or [])),
|
||
("证据来源与边界", source_text(report.get("evidence_sources") or {})),
|
||
("验证结论", report["verdict"]),
|
||
("人工复验时间", time_text((report.get("test_result") or {}).get("reviewed_at"))),
|
||
(
|
||
"原始结果"
|
||
if ((report.get("test_result") or {}).get("ai_result") or {}).get(
|
||
"verification_skipped"
|
||
)
|
||
else "原 AI 结论",
|
||
verdict({"test_result": (report.get("test_result") or {}).get("ai_result")})
|
||
if (report.get("test_result") or {}).get("source") == "human"
|
||
else "—",
|
||
),
|
||
("判定依据", (report.get("test_result") or {}).get("reason") or "未记录"),
|
||
(
|
||
"验收证据",
|
||
"\n".join((report.get("test_result") or {}).get("evidence") or []) or "未记录",
|
||
),
|
||
("开始时间", time_text(report["start"])),
|
||
("结束时间", time_text(report["end"])),
|
||
("设备", report["device"]),
|
||
("异常原因", report["error"] or "无独立异常记录"),
|
||
]
|
||
|
||
|
||
def config_text(config) -> str:
|
||
if not isinstance(config, dict):
|
||
return text(config or {})
|
||
return json.dumps(
|
||
{key: value for key, value in config.items() if value is not None},
|
||
ensure_ascii=False,
|
||
indent=2,
|
||
)
|
||
|
||
|
||
def image_path(name: str | None) -> Path | None:
|
||
if not name:
|
||
return None
|
||
root = Path(IMAGES_DIR).resolve()
|
||
path = (root / (name if Path(name).suffix else name + ".jpg")).resolve()
|
||
return (
|
||
path
|
||
if path.is_relative_to(root)
|
||
and path.is_file()
|
||
and path.suffix.lower() in {".jpg", ".png", ".jpeg"}
|
||
else None
|
||
)
|
||
|
||
|
||
def markdown_blocks(content: str):
|
||
lines = content.splitlines()
|
||
index = 0
|
||
in_code = False
|
||
while index < len(lines):
|
||
line = lines[index]
|
||
if line.strip().startswith("```"):
|
||
in_code = not in_code
|
||
if (
|
||
not in_code
|
||
and "|" in line
|
||
and index + 1 < len(lines)
|
||
and re.fullmatch(r"[\s|:\-]+", lines[index + 1])
|
||
and "-" in lines[index + 1]
|
||
):
|
||
rows = [[c.strip() for c in line.strip().strip("|").split("|")]]
|
||
index += 2
|
||
while index < len(lines) and "|" in lines[index] and lines[index].strip():
|
||
rows.append([c.strip() for c in lines[index].strip().strip("|").split("|")])
|
||
index += 1
|
||
yield "table", rows
|
||
else:
|
||
yield "text", line
|
||
index += 1
|
||
|
||
|
||
def word_styles(doc, *, landscape: bool = False):
|
||
section = doc.sections[0]
|
||
section.page_width, section.page_height = (
|
||
(Cm(29.7), Cm(21)) if landscape else (Cm(21), Cm(29.7))
|
||
)
|
||
section.left_margin = section.right_margin = Cm(2)
|
||
section.top_margin = section.bottom_margin = Cm(1.9)
|
||
for name, size, color in (
|
||
("Normal", 10.5, "263445"),
|
||
("Title", 20, "0F172A"),
|
||
("Heading 1", 14, "0F172A"),
|
||
("Heading 2", 11.5, "0F172A"),
|
||
("Heading 3", 10.5, "0F172A"),
|
||
("List Bullet", 10.5, "263445"),
|
||
("List Number", 10.5, "263445"),
|
||
("Quote", 10.5, "263445"),
|
||
):
|
||
style = cast(ParagraphStyle, doc.styles[name])
|
||
style.font.name = "Microsoft YaHei"
|
||
style.font.size = Pt(size)
|
||
style.font.color.rgb = RGBColor.from_string(color)
|
||
style.element.get_or_add_rPr().get_or_add_rFonts().set(qn("w:eastAsia"), "微软雅黑")
|
||
style.paragraph_format.space_after = Pt(7 if name == "Normal" else 9)
|
||
if name == "Normal":
|
||
style.paragraph_format.line_spacing = 1.3
|
||
if name == "Title":
|
||
ppr = style.element.get_or_add_pPr()
|
||
border = ppr.find(qn("w:pBdr"))
|
||
if border is not None:
|
||
ppr.remove(border)
|
||
return doc
|
||
|
||
|
||
def shade_cell(cell, fill: str):
|
||
shading = OxmlElement("w:shd")
|
||
shading.set(qn("w:fill"), fill)
|
||
cell._tc.get_or_add_tcPr().append(shading)
|
||
|
||
|
||
def word_table(doc, rows, widths: tuple[float, ...], *, header: bool = False):
|
||
table = doc.add_table(rows=0, cols=len(widths))
|
||
table.autofit = False
|
||
table.style = "Table Grid"
|
||
borders = OxmlElement("w:tblBorders")
|
||
for edge in ("top", "left", "bottom", "right", "insideH", "insideV"):
|
||
line = OxmlElement(f"w:{edge}")
|
||
line.set(qn("w:val"), "single")
|
||
line.set(qn("w:sz"), "4")
|
||
line.set(qn("w:color"), "D9D9D9")
|
||
borders.append(line)
|
||
table._tbl.tblPr.append(borders)
|
||
for column, width in zip(table.columns, widths):
|
||
column.width = Cm(width)
|
||
for index, row in enumerate(rows):
|
||
cells = table.add_row().cells
|
||
if header and index == 0:
|
||
table.rows[-1]._tr.get_or_add_trPr().append(OxmlElement("w:tblHeader"))
|
||
for position, cell in enumerate(cells):
|
||
cell.width = Cm(widths[position])
|
||
cell.vertical_alignment = WD_CELL_VERTICAL_ALIGNMENT.CENTER
|
||
cell.text = text(row[position]) if position < len(row) else ""
|
||
margins = OxmlElement("w:tcMar")
|
||
for edge, size in (("top", "85"), ("bottom", "85"), ("left", "110"), ("right", "110")):
|
||
margin = OxmlElement(f"w:{edge}")
|
||
margin.set(qn("w:w"), size)
|
||
margin.set(qn("w:type"), "dxa")
|
||
margins.append(margin)
|
||
cell._tc.get_or_add_tcPr().append(margins)
|
||
if (header and index == 0) or (not header and position == 0):
|
||
shade_cell(cell, "DDEBF5")
|
||
for run in cell.paragraphs[0].runs:
|
||
run.bold = True
|
||
elif index % 2 == 0:
|
||
shade_cell(cell, "F6F9FC")
|
||
for paragraph in cell.paragraphs:
|
||
paragraph.paragraph_format.space_after = Pt(3)
|
||
for run in paragraph.runs:
|
||
run.font.size = Pt(8.5 if len(widths) > 2 else 9.5)
|
||
doc.add_paragraph().paragraph_format.space_after = Pt(2)
|
||
return table
|
||
|
||
|
||
def add_markdown_inline(paragraph, value: str):
|
||
"""Keep emphasis readable in Word without importing untrusted HTML."""
|
||
pieces = re.split(r"(\*\*[^*]+\*\*|`[^`]+`|\*[^*]+\*)", value)
|
||
for piece in pieces:
|
||
if not piece:
|
||
continue
|
||
run = paragraph.add_run(
|
||
piece.strip("*")
|
||
if piece.startswith("*")
|
||
else piece.strip("`")
|
||
if piece.startswith("`")
|
||
else piece
|
||
)
|
||
run.bold = piece.startswith("**")
|
||
run.italic = piece.startswith("*") and not piece.startswith("**")
|
||
if piece.startswith("`"):
|
||
run.font.name = "Consolas"
|
||
|
||
|
||
def add_markdown_content(doc, content: str):
|
||
in_code = False
|
||
for kind, value in markdown_blocks(text(content)):
|
||
if kind == "table":
|
||
columns = max(map(len, value))
|
||
if columns:
|
||
word_table(doc, value, tuple(16 / columns for _ in range(columns)), header=True)
|
||
continue
|
||
line = str(value)
|
||
if line.strip().startswith("```"):
|
||
in_code = not in_code
|
||
continue
|
||
if in_code:
|
||
paragraph = doc.add_paragraph()
|
||
shade = OxmlElement("w:shd")
|
||
shade.set(qn("w:fill"), "F1F5F9")
|
||
paragraph._p.get_or_add_pPr().append(shade)
|
||
paragraph.add_run(line).font.name = "Consolas"
|
||
elif not line.strip():
|
||
continue
|
||
elif match := re.match(r"^(#{1,3})\s+(.+)$", line):
|
||
doc.add_heading(match.group(2), level=min(len(match.group(1)) + 1, 3))
|
||
elif match := re.match(r"^\s*([-*+] |\d+\. )(.+)$", line):
|
||
paragraph = doc.add_paragraph(
|
||
style="List Number" if match.group(1)[0].isdigit() else "List Bullet"
|
||
)
|
||
add_markdown_inline(paragraph, match.group(2))
|
||
else:
|
||
paragraph = doc.add_paragraph(style="Quote" if line.lstrip().startswith("> ") else None)
|
||
add_markdown_inline(
|
||
paragraph, line.lstrip("> ") if line.lstrip().startswith("> ") else line
|
||
)
|
||
|
||
|
||
def plugin_operations(steps: list[dict]) -> list[dict]:
|
||
operations = []
|
||
for step in steps:
|
||
for trace in step.get("generic_tools", []):
|
||
payload = trace.get("payload") or {}
|
||
if isinstance(payload, str):
|
||
try:
|
||
payload = json.loads(payload)
|
||
except ValueError:
|
||
continue
|
||
if not isinstance(payload, dict) or not payload.get("plugin_id"):
|
||
continue
|
||
result = payload.get("result") or {}
|
||
if isinstance(result, str):
|
||
try:
|
||
result = json.loads(result)
|
||
except ValueError:
|
||
result = {}
|
||
if not isinstance(result, dict):
|
||
result = {}
|
||
content = "\n".join(
|
||
str(block.get("text", ""))
|
||
for block in result.get("content", [])
|
||
if isinstance(block, dict) and block.get("type") == "text"
|
||
)
|
||
source = result.get("source") or payload.get("source") or {}
|
||
evidence = []
|
||
if result.get("call_id"):
|
||
evidence.append("调用：" + str(result["call_id"]))
|
||
if source:
|
||
evidence.append(
|
||
f"来源：{source.get('kind', '')} · {source.get('label') or source.get('target_id', '')}"
|
||
)
|
||
if result.get("execution"):
|
||
evidence.append(
|
||
f"执行：{result['execution']}；副作用：{result.get('side_effect', 'unknown')}；错误码：{result.get('error_code') or '无'}"
|
||
)
|
||
for attachment in result.get("attachments") or []:
|
||
evidence.append(
|
||
f"文件：{attachment.get('name')}；SHA-256：{attachment.get('sha256')}"
|
||
)
|
||
if evidence:
|
||
content = "\n".join([content or result.get("message") or "", *evidence])
|
||
operations.append(
|
||
{
|
||
"step": step.get("step_number"),
|
||
"plugin": payload["plugin_id"],
|
||
"version": payload.get("plugin_version", ""),
|
||
"tool": result.get("tool") or trace.get("name"),
|
||
"resources": ", ".join(payload.get("resource_ids") or []),
|
||
"status": result.get("status") or trace.get("status", "unknown"),
|
||
"content": (
|
||
content or payload.get("error") or result.get("message") or "未返回文字证据"
|
||
)[:6000],
|
||
}
|
||
)
|
||
return operations
|
||
|
||
|
||
def word_report(report: dict, path: Path):
|
||
doc = word_styles(Document())
|
||
doc.add_paragraph(report["name"], style="Title")
|
||
doc.add_paragraph(
|
||
f"执行状态：{STATUS.get(report['status'], report['status'])} 验证结论：{report['verdict']}"
|
||
)
|
||
if report["error"]:
|
||
doc.add_heading("异常原因", 1)
|
||
doc.add_paragraph(text(report["error"]))
|
||
if result := report.get("test_result"):
|
||
doc.add_heading("测试结论与依据", 1)
|
||
doc.add_paragraph(text(result.get("reason") or "未记录"))
|
||
for evidence in result.get("evidence") or []:
|
||
doc.add_paragraph(text(evidence), style="List Bullet")
|
||
doc.add_heading("任务信息", 1)
|
||
details = [
|
||
(label, value)
|
||
for label, value in metadata(report)
|
||
if label
|
||
in {
|
||
"任务编号",
|
||
"用例编号",
|
||
"检测项目",
|
||
"测试子项",
|
||
"开始时间",
|
||
"结束时间",
|
||
"设备",
|
||
"耗时分项",
|
||
"指导消费",
|
||
"证据来源与边界",
|
||
}
|
||
]
|
||
word_table(doc, details, (3.2, 13.3))
|
||
doc.add_heading("任务目标与预期" if not report["expected"] else "任务目标", 2)
|
||
doc.add_paragraph(report["goal"] or "未记录")
|
||
if report["expected"]:
|
||
doc.add_heading("预期结果", 2)
|
||
doc.add_paragraph(report["expected"])
|
||
if report.get("preconditions"):
|
||
doc.add_paragraph("前置约束：" + text(report["preconditions"]))
|
||
if report.get("task_config"):
|
||
doc.add_paragraph("任务配置：" + config_text(report["task_config"]))
|
||
doc.add_heading("结论与发现", 1)
|
||
add_markdown_content(doc, report["content"])
|
||
if review_rows := extension_rows(report):
|
||
doc.add_heading("人工评审（插件）", 1)
|
||
word_table(
|
||
doc, [(f"{name} · {label}", value) for name, label, value in review_rows], (5.5, 11)
|
||
)
|
||
doc.add_heading("执行步骤与证据", 1)
|
||
for step in report["steps"]:
|
||
paragraph = doc.add_paragraph()
|
||
paragraph.paragraph_format.keep_together = True
|
||
paragraph.add_run(
|
||
f"步骤 {step['step_number']} · {time_text(step.get('timestamp'))}\n"
|
||
).bold = True
|
||
paragraph.add_run(step.get("summary") or "已记录操作")
|
||
operations = plugin_operations(report["steps"])
|
||
if operations:
|
||
doc.add_heading("扩展插件操作", 2)
|
||
for operation in operations:
|
||
doc.add_paragraph(
|
||
f"步骤 {operation['step']} · {operation['plugin']} v{operation['version']} · {operation['tool']} · {operation['status']}"
|
||
)
|
||
doc.add_paragraph("资源：" + operation["resources"])
|
||
doc.add_paragraph(operation["content"])
|
||
evidence = report["steps"][:1] + report["steps"][-1:]
|
||
seen: set[str] = set()
|
||
images: list[tuple[Path, int]] = []
|
||
for step in evidence:
|
||
name = step.get("post_image_name") or step.get("pre_image_name")
|
||
photo = image_path(name)
|
||
if photo and name not in seen:
|
||
seen.add(name)
|
||
images.append((photo, step["step_number"]))
|
||
if images:
|
||
doc.add_page_break()
|
||
doc.add_heading("关键截图", 2)
|
||
table = doc.add_table(rows=1, cols=len(images))
|
||
table.autofit = False
|
||
for cell, (photo, step_number) in zip(table.rows[0].cells, images):
|
||
cell.width = Cm(8 if len(images) == 2 else 12)
|
||
cell.paragraphs[0].add_run(f"步骤 {step_number}").bold = True
|
||
cell.add_paragraph().add_run().add_picture(
|
||
str(photo), width=Cm(7.5 if len(images) == 2 else 8.5)
|
||
)
|
||
doc.add_paragraph("其余步骤截图可从任务资料包单独下载。")
|
||
doc.add_paragraph(f"追溯编号：{report['id']}。未观察、未检查的项目不计为验证通过。")
|
||
doc.save(str(path))
|
||
|
||
|
||
def sheet_rows(ws, rows, widths: tuple[int, ...] = ()):
|
||
ws.sheet_view.showGridLines = False
|
||
ws.freeze_panes = "A2"
|
||
ws.sheet_properties.pageSetUpPr.fitToPage = True
|
||
ws.page_setup.fitToWidth = 1
|
||
if len(widths) > 3:
|
||
ws.page_setup.orientation = "landscape"
|
||
ws.page_setup.paperSize = ws.PAPERSIZE_A3
|
||
ws.print_options.horizontalCentered = True
|
||
for index, row in enumerate(rows, 1):
|
||
ws.append([text(value)[:32700] if value is not None else "" for value in row])
|
||
longest = 1
|
||
for column, cell in enumerate(ws[index], 1):
|
||
# Always store text, including leading '=': never export executable formulas.
|
||
cell.data_type = "s"
|
||
cell.alignment = Alignment(wrap_text=True, vertical="center" if index == 1 else "top")
|
||
cell.font = Font(
|
||
name="微软雅黑",
|
||
size=10,
|
||
bold=index == 1,
|
||
color="FFFFFF" if index == 1 else "253244",
|
||
)
|
||
cell.border = Border(bottom=Side(style="hair", color="E2E8F0"))
|
||
if index == 1:
|
||
cell.fill = PatternFill("solid", fgColor="245C78")
|
||
elif index % 2 == 1 or column == 1:
|
||
cell.fill = PatternFill("solid", fgColor="F3F7FA" if column == 1 else "F8FAFC")
|
||
width = widths[column - 1] if column <= len(widths) else 32
|
||
ws.column_dimensions[get_column_letter(column)].width = width
|
||
lines = str(cell.value or "").splitlines() or [""]
|
||
height_lines = sum(
|
||
max(1, (sum(2 if ord(char) > 255 else 1 for char in line) + width - 1) // width)
|
||
for line in lines
|
||
)
|
||
longest = max(longest, height_lines)
|
||
ws.row_dimensions[index].height = 30 if index == 1 else min(300, max(27, longest * 18 + 8))
|
||
if ws.max_row > 1:
|
||
ws.auto_filter.ref = ws.dimensions
|
||
|
||
|
||
def conclusion_rows(content: str):
|
||
rows = [("类型", "结论与发现")]
|
||
table_number = 0
|
||
in_code = False
|
||
for kind, value in markdown_blocks(content):
|
||
if kind == "table":
|
||
table_number += 1
|
||
rows.append(("表格", f"详见「结果表{table_number}」工作表"))
|
||
elif line := str(value).strip():
|
||
if line.startswith("```"):
|
||
in_code = not in_code
|
||
continue
|
||
if in_code:
|
||
rows.append(("代码", line))
|
||
continue
|
||
if match := re.match(r"^#{1,6}\s+(.*)$", line):
|
||
label, body = "小节", match.group(1)
|
||
elif match := re.match(r"^(?:[-*+] |\d+\. )(.*)$", line):
|
||
label, body = "要点", match.group(1)
|
||
else:
|
||
label, body = "正文", line.lstrip("> ")
|
||
rows.append(
|
||
(
|
||
label,
|
||
re.sub(r"\*\*([^*]+)\*\*|`([^`]+)`", lambda m: m.group(1) or m.group(2), body),
|
||
)
|
||
)
|
||
return rows
|
||
|
||
|
||
def execution_result_label(result) -> str:
|
||
if not isinstance(result, dict):
|
||
return text(result or "未记录")[:120]
|
||
status = result.get("status")
|
||
labels = {
|
||
"dispatched": "动作已发出（需核对截图）",
|
||
"success": "动作返回成功",
|
||
"failed": "动作失败",
|
||
}
|
||
label = labels.get(status, text(status or "未记录"))
|
||
if result.get("error"):
|
||
label += "\n" + text(result["error"])[:180]
|
||
return label
|
||
|
||
|
||
def excel_report(report: dict, path: Path):
|
||
wb = Workbook()
|
||
assert wb.active is not None
|
||
wb.active.title = "任务结果"
|
||
sheet_rows(wb.active, [("项目", "内容"), *metadata(report)], (22, 82))
|
||
sheet_rows(wb.create_sheet("结论"), conclusion_rows(report["content"]), (15, 96))
|
||
if review_rows := extension_rows(report):
|
||
sheet_rows(
|
||
wb.create_sheet("人工评审"), [("插件", "项目", "内容"), *review_rows], (24, 30, 82)
|
||
)
|
||
table_number = 0
|
||
for kind, rows in markdown_blocks(report["content"]):
|
||
if kind == "table":
|
||
table_number += 1
|
||
sheet_rows(wb.create_sheet(f"结果表{table_number}"), rows)
|
||
sheet_rows(
|
||
wb.create_sheet("执行证据"),
|
||
[
|
||
("步骤", "时间", "说明", "结果", "截图引用"),
|
||
*[
|
||
(
|
||
s["step_number"],
|
||
time_text(s.get("timestamp")),
|
||
s.get("summary"),
|
||
execution_result_label(s.get("last_execution_result")),
|
||
"见步骤截图资料包"
|
||
if s.get("post_image_name") or s.get("pre_image_name")
|
||
else "无截图",
|
||
)
|
||
for s in report["steps"]
|
||
],
|
||
],
|
||
(10, 22, 68, 26, 24),
|
||
)
|
||
operations = plugin_operations(report["steps"])
|
||
if operations:
|
||
sheet_rows(
|
||
wb.create_sheet("插件操作"),
|
||
[
|
||
("步骤", "插件", "版本", "工具", "资源", "调用状态", "观察与结果"),
|
||
*[
|
||
(
|
||
op["step"],
|
||
op["plugin"],
|
||
op["version"],
|
||
op["tool"],
|
||
op["resources"],
|
||
op["status"],
|
||
op["content"],
|
||
)
|
||
for op in operations
|
||
],
|
||
],
|
||
(10, 24, 14, 26, 24, 16, 80),
|
||
)
|
||
wb.save(path)
|
||
|
||
|
||
def export_session(
|
||
session_id: str, formats: list[str] | None = None, *, report: dict | None = None
|
||
) -> list[Path]:
|
||
with export_lock("session:" + identifier(session_id)):
|
||
report = report if report is not None else session_report(session_id)
|
||
signature = fingerprint(report, session_screenshots(report))
|
||
directory = EXPORT_ROOT / "sessions" / identifier(session_id)
|
||
directory.mkdir(parents=True, exist_ok=True)
|
||
outputs = []
|
||
for fmt in formats if formats is not None else store.preferences()["formats"]:
|
||
if fmt not in {"docx", "xlsx"}:
|
||
raise ValueError("不支持的报告格式")
|
||
path = directory / f"任务报告.{fmt}"
|
||
if reusable(path, signature, report["status"]):
|
||
outputs.append(path)
|
||
continue
|
||
temporary = directory / f"生成中.{fmt}"
|
||
(word_report if fmt == "docx" else excel_report)(report, temporary)
|
||
temporary.replace(path)
|
||
remember(path, signature)
|
||
outputs.append(path)
|
||
return outputs
|
||
|
||
|
||
def session_screenshots(report: dict) -> list[tuple[Path, str]]:
|
||
"""Ordered, path-checked pre/post observations for each recorded step."""
|
||
screenshots: list[tuple[Path, str]] = []
|
||
for index, step in enumerate(report["steps"], 1):
|
||
for phase, key in (("操作前", "pre_image_name"), ("操作后", "post_image_name")):
|
||
source = image_path(step.get(key))
|
||
if source:
|
||
screenshots.append(
|
||
(
|
||
source,
|
||
f"{index:04d}_步骤{int(step.get('step_number') or index):04d}_{phase}{source.suffix.lower()}",
|
||
)
|
||
)
|
||
# Plugin observations are attached to their own tool traces rather than
|
||
# replacing a phone's step image in a mixed task.
|
||
seen: set[tuple[str, str]] = set()
|
||
for tool_index, trace in enumerate(step.get("generic_tools", []), 1):
|
||
payload = trace.get("payload") or {}
|
||
if isinstance(payload, str):
|
||
try:
|
||
payload = json.loads(payload)
|
||
except ValueError:
|
||
continue
|
||
if not isinstance(payload, dict) or not payload.get("plugin_id"):
|
||
continue
|
||
plugin_id = re.sub(r"[^a-zA-Z0-9_-]", "_", str(payload["plugin_id"]))[:48]
|
||
names = payload.get("image_names") or [payload.get("post_image_name")]
|
||
for image_index, name in enumerate(names, 1):
|
||
source = image_path(name)
|
||
if source and (plugin_id, str(name)) not in seen:
|
||
seen.add((plugin_id, str(name)))
|
||
screenshots.append(
|
||
(
|
||
source,
|
||
f"{index:04d}_插件_{plugin_id}_{tool_index:03d}_{image_index:02d}{source.suffix.lower()}",
|
||
)
|
||
)
|
||
return screenshots
|
||
|
||
|
||
def session_videos(report: dict) -> list[tuple[Path, str]]:
|
||
"""Find only verified files attached to this session's recording directory."""
|
||
session = SessionRepository().get_session_by_id(report["id"]) or {}
|
||
recording = SessionRepository().get_video_recording_for_session(report["id"]) or {}
|
||
candidate = recording.get("local_video_path") or session.get("video_filepath")
|
||
if not candidate:
|
||
return []
|
||
source = Path(str(candidate)).resolve()
|
||
trace_root = TRACES_PATH.resolve()
|
||
# The recording row already ties the finalized trace folder to this session.
|
||
if not source.is_relative_to(trace_root):
|
||
return []
|
||
# A resumed recording lives under resume_NNNN; the initial recording is
|
||
# in its parent, with any later segments in sibling resume folders.
|
||
directory = source.parent
|
||
if directory.name.startswith("resume_"):
|
||
directory = directory.parent
|
||
if not directory.is_dir() or not directory.is_relative_to(trace_root):
|
||
return []
|
||
paths = [
|
||
p
|
||
for p in directory.rglob("*.mp4")
|
||
if p.is_file()
|
||
and p.resolve().is_relative_to(directory.resolve())
|
||
and (p.parent == directory or p.parent.name.startswith("resume_"))
|
||
]
|
||
paths.sort(key=lambda p: (0 if p.parent == directory else 1, p.parent.name, p.name))
|
||
return [(path, f"{i:04d}_{path.parent.name}_{path.name}") for i, path in enumerate(paths, 1)]
|
||
|
||
|
||
def session_artifacts(report: dict) -> list[tuple[Path, str]]:
|
||
"""Only completed, task-owned Android files; never follow external links."""
|
||
traces = TRACES_PATH.resolve()
|
||
root = traces / identifier(report["id"]) / "artifacts" / "android"
|
||
if not root.is_dir() or root.resolve() != root:
|
||
return []
|
||
return [
|
||
(path, path.name)
|
||
for path in sorted(root.iterdir())
|
||
if path.is_file()
|
||
and not path.is_symlink()
|
||
and not path.name.startswith(".artemis-")
|
||
and path.resolve().parent == root.resolve()
|
||
]
|
||
|
||
|
||
def session_download(session_id: str, kind: str) -> tuple[Path, str]:
|
||
with export_lock("session:" + identifier(session_id)):
|
||
report = session_report(session_id)
|
||
return export_session_media(session_id, kind, report=report), archive_case_name(report)
|
||
|
||
|
||
def export_session_media(session_id: str, kind: str, *, report: dict | None = None) -> Path:
|
||
from apps.admin_console.services.evidence_service import export_index, plugin_files
|
||
|
||
if kind not in {"screenshots", "video", "all"}:
|
||
raise ValueError("不支持的下载类型")
|
||
with export_lock("session:" + identifier(session_id)):
|
||
report = report if report is not None else session_report(session_id)
|
||
target_dir = EXPORT_ROOT / "sessions" / identifier(session_id)
|
||
target_dir.mkdir(parents=True, exist_ok=True)
|
||
images = session_screenshots(report) if kind in {"screenshots", "all"} else []
|
||
videos = session_videos(report) if kind in {"video", "all"} else []
|
||
artifacts = session_artifacts(report) if kind == "all" else []
|
||
extras = plugin_files(session_id) if kind in {"video", "all"} else []
|
||
if kind == "video":
|
||
extras = [
|
||
(path, name)
|
||
for path, name in extras
|
||
if path.suffix.lower() in {".mp4", ".mkv", ".webm"}
|
||
]
|
||
if kind == "video" and not videos and not extras:
|
||
raise ValueError("此任务没有已保存的录屏")
|
||
if kind == "screenshots" and not images:
|
||
raise ValueError("此任务没有可下载的步骤截图")
|
||
target = target_dir / f"{kind}.zip"
|
||
temporary = target_dir / f".{kind}.tmp"
|
||
files = images + videos + artifacts + extras
|
||
diagnostics = diagnostics_json(session_id) if kind == "all" else None
|
||
diagnostic_state = json.loads(diagnostics) if diagnostics else None
|
||
if isinstance(diagnostic_state, dict):
|
||
diagnostic_state.pop("collected_at", None)
|
||
signature = fingerprint(report, files, diagnostic_state)
|
||
if reusable(target, signature, report["status"]):
|
||
return target
|
||
manifest = {
|
||
"session_id": session_id,
|
||
"name": report["name"],
|
||
"status": report["status"],
|
||
"verdict": report["verdict"],
|
||
"screenshots": [name for _, name in images],
|
||
"videos": ["任务录屏/安卓/" + name for _, name in videos]
|
||
+ [name for path, name in extras if path.suffix.lower() in {".mp4", ".mkv", ".webm"}],
|
||
"artifacts": [name for _, name in artifacts],
|
||
"note": "录屏按时间顺序分段；暂停期间未占用设备，也未录制其他任务。",
|
||
"snapshot": report["status"]
|
||
not in {"completed", "success", "failed", "cancelled", "interrupted", "skipped"},
|
||
}
|
||
prefix = archive_case_name(report) + "/" if kind == "all" else ""
|
||
with zipfile.ZipFile(temporary, "w", zipfile.ZIP_DEFLATED) as archive:
|
||
if kind == "all":
|
||
for path in export_session(session_id, ["docx", "xlsx"], report=report):
|
||
archive.write(path, prefix + path.name, compress_type=compression(path))
|
||
for source, name in images:
|
||
archive.write(source, f"{prefix}步骤截图/{name}", compress_type=compression(source))
|
||
for source, name in videos:
|
||
archive.write(
|
||
source, f"{prefix}任务录屏/安卓/{name}", compress_type=zipfile.ZIP_STORED
|
||
)
|
||
for source, name in artifacts:
|
||
archive.write(
|
||
source, f"{prefix}任务文件/安卓/{name}", compress_type=compression(source)
|
||
)
|
||
for source, name in extras:
|
||
archive.write(
|
||
source,
|
||
prefix + name,
|
||
compress_type=compression(source),
|
||
)
|
||
if kind == "all":
|
||
archive.writestr(prefix + "模型请求诊断.json", diagnostics or "{}")
|
||
archive.writestr(
|
||
prefix + "运行环境诊断.json",
|
||
json.dumps(
|
||
{
|
||
"runtime": report.get("runtime_diagnostics"),
|
||
"batch": report.get("batch_diagnostics"),
|
||
},
|
||
ensure_ascii=False,
|
||
indent=2,
|
||
),
|
||
)
|
||
archive.writestr(
|
||
prefix + "证据索引.json",
|
||
json.dumps(
|
||
export_index(
|
||
session_id,
|
||
report,
|
||
videos,
|
||
images=images,
|
||
artifacts=artifacts,
|
||
extras=extras,
|
||
),
|
||
ensure_ascii=False,
|
||
indent=2,
|
||
default=str,
|
||
),
|
||
)
|
||
archive.writestr(
|
||
prefix + "文件清单.json", json.dumps(manifest, ensure_ascii=False, indent=2)
|
||
)
|
||
temporary.replace(target)
|
||
if fingerprint(report, files, diagnostic_state) == signature:
|
||
remember(target, signature)
|
||
return target
|
||
|
||
|
||
def export_batch(batch_id: str, progress: Callable[[int, int, str], None] | None = None) -> Path:
|
||
from apps.admin_console.services.evidence_service import export_index, plugin_files
|
||
|
||
with export_lock(
|
||
"batch:" + identifier(batch_id),
|
||
*("session:" + job["session_id"] for job in store.jobs(batch_id)),
|
||
):
|
||
batch = store.get("batch", identifier(batch_id))
|
||
if not batch:
|
||
raise ValueError("批次不存在")
|
||
directory = EXPORT_ROOT / "batches" / batch_id
|
||
directory.mkdir(parents=True, exist_ok=True)
|
||
formats = batch["formats"]
|
||
with task_extensions.plugin_store().mutation_lock:
|
||
signature = batch_archive_signature(batch_id)
|
||
records = [session_report(job["session_id"]) for job in store.jobs(batch_id)]
|
||
if progress:
|
||
progress(0, len(records), "正在生成批次汇总")
|
||
rows = [("任务编号", "任务名称", "执行状态", "验证结论", "异常原因")]
|
||
rows += [
|
||
(r["id"], r["name"], STATUS.get(r["status"], r["status"]), r["verdict"], r["error"])
|
||
for r in records
|
||
]
|
||
outputs = []
|
||
if "xlsx" in formats:
|
||
wb = Workbook()
|
||
assert wb.active is not None
|
||
wb.active.title = "批次结果"
|
||
sheet_rows(wb.active, rows, (40, 48, 16, 28, 70))
|
||
review_rows = [
|
||
(record["id"], record["name"], *row)
|
||
for record in records
|
||
for row in extension_rows(record)
|
||
]
|
||
if review_rows:
|
||
sheet_rows(
|
||
wb.create_sheet("人工评审"),
|
||
[("任务编号", "任务名称", "插件", "项目", "内容"), *review_rows],
|
||
(40, 40, 24, 30, 70),
|
||
)
|
||
path = directory / "批次结果.xlsx"
|
||
wb.save(path)
|
||
outputs.append(path)
|
||
if "docx" in formats:
|
||
doc = word_styles(Document(), landscape=True)
|
||
doc.add_paragraph(batch["name"], style="Title")
|
||
doc.add_paragraph(
|
||
f"批次编号：{batch_id}；共 {len(records)} 个任务。验证通过与执行完成分别统计。"
|
||
)
|
||
word_table(doc, rows, (3.5, 5.4, 2.5, 3.5, 7.3), header=True)
|
||
for record in records:
|
||
if review_rows := extension_rows(record):
|
||
doc.add_heading("人工评审 · " + record["name"], 1)
|
||
doc.add_paragraph("任务编号：" + record["id"])
|
||
word_table(
|
||
doc,
|
||
[(f"{name} · {label}", value) for name, label, value in review_rows],
|
||
(7, 15.2),
|
||
)
|
||
path = directory / "批次汇总.docx"
|
||
doc.save(str(path))
|
||
outputs.append(path)
|
||
target = directory / "批次报告.zip"
|
||
temporary = directory / "批次报告.tmp"
|
||
with zipfile.ZipFile(temporary, "w", zipfile.ZIP_DEFLATED) as archive:
|
||
for path in outputs:
|
||
archive.write(path, path.name, compress_type=compression(path))
|
||
for number, report in enumerate(records, 1):
|
||
if progress:
|
||
progress(number - 1, len(records), f"正在打包任务 {number}/{len(records)}")
|
||
prefix = f"任务报告/{number:04d}_{archive_case_name(report)}"
|
||
images = session_screenshots(report)
|
||
videos = session_videos(report)
|
||
artifacts = session_artifacts(report)
|
||
extras = plugin_files(report["id"])
|
||
for path in export_session(report["id"], formats, report=report):
|
||
archive.write(path, f"{prefix}/{path.name}", compress_type=compression(path))
|
||
for source, name in images:
|
||
archive.write(
|
||
source, f"{prefix}/步骤截图/{name}", compress_type=compression(source)
|
||
)
|
||
for source, name in videos:
|
||
archive.write(
|
||
source, f"{prefix}/任务录屏/安卓/{name}", compress_type=zipfile.ZIP_STORED
|
||
)
|
||
for source, name in artifacts:
|
||
archive.write(
|
||
source, f"{prefix}/任务文件/安卓/{name}", compress_type=compression(source)
|
||
)
|
||
for source, name in extras:
|
||
archive.write(
|
||
source,
|
||
f"{prefix}/{name}",
|
||
compress_type=compression(source),
|
||
)
|
||
archive.writestr(f"{prefix}/模型请求诊断.json", diagnostics_json(report["id"]))
|
||
archive.writestr(
|
||
f"{prefix}/运行环境诊断.json",
|
||
json.dumps(
|
||
{
|
||
"runtime": report.get("runtime_diagnostics"),
|
||
"batch": report.get("batch_diagnostics"),
|
||
},
|
||
ensure_ascii=False,
|
||
indent=2,
|
||
),
|
||
)
|
||
archive.writestr(
|
||
f"{prefix}/证据索引.json",
|
||
json.dumps(
|
||
export_index(
|
||
report["id"],
|
||
report,
|
||
videos,
|
||
images=images,
|
||
artifacts=artifacts,
|
||
extras=extras,
|
||
),
|
||
ensure_ascii=False,
|
||
indent=2,
|
||
default=str,
|
||
),
|
||
)
|
||
if progress:
|
||
progress(number, len(records), f"已打包任务 {number}/{len(records)}")
|
||
if progress:
|
||
progress(len(records), len(records), "正在完成压缩包")
|
||
temporary.replace(target)
|
||
remember(target, signature)
|
||
return target
|