Методика оценки: судья по эталону мерит точность, полноту и галлюцинации, Q = 100 × (0,4·Т + 0,4·П + 0,2·Г); прогонщик DeepSeek Harness и тесты оценки
67df8f6 verified | """Проверки кодом: то, что в выдаче системы можно сверить без модели. | |
| Вход: строка задачи из ``data/tasks.jsonl`` (поле ``checks``) и запись прогона системы по задаче | |
| (``<прогон>/<система>/<задача>/record.json``, формат ниже). Выход: список проверок с исходом и пояснением в | |
| ``checks.json`` рядом с записью. | |
| Запись прогона (одна для любой системы; прогонщик бенчмарка пишет её одинаково для каждой):: | |
| { | |
| "task_id": "...", "system": "santify" | "dsh" | ..., | |
| "status": "completed" | "asked" | "deadline" | "failed" | "prep_failed" | "not_run", | |
| # not_run — задачу система не запускала: нужная возможность ей в прогоне не | |
| # подключена (причина в error); в итог системы такая задача не входит | |
| "asked": false, # система закончила вопросом человеку (остановка сроком задачи — не вопрос) | |
| "answer": "...", # последний ответ системы человеку | |
| "turns": [{"text": "...", "answer": "...", "asked": false, "seconds": 12.3, "reply": false}], | |
| # asked хода — ответ системы был вопросом; reply — сообщение было ответом человека | |
| "files": [{"name": "Договор.docx", "path": "files/Договор.docx", "sha256": "..."}], | |
| "actions": [{"kind": "tool" | "shell", "name": "...", "arguments": "..."}], | |
| "storage_after": [{"name": "Снабжение/Счёт.pdf", "sha256": "..."}], | |
| "state": {"reminders": [...], "automations": [...], "board_tasks": [...], "notes": [...]}, | |
| "started": "2026-10-21T10:00:00+03:00", "seconds": 123.4, "model_calls": 17, | |
| "prompt_tokens": 123456, "completion_tokens": 7890, "error": null | |
| } | |
| Текст выданных файлов читает ``extract.py``, одинаково для любой системы. | |
| Виды проверок (поле ``kind``): | |
| * ``file`` / ``no_file``: выдан (не выдан) файл с расширением ``ext``; | |
| * ``text``: все признаки ``all`` есть в ответе или выданных файлах (``where``: ``answer`` или ``files``, по умолчанию оба). | |
| Ответ — последний; с ``turn`` (номер сообщения человека, с 1) — ответ на это сообщение. Поле ``turn`` понимают все | |
| проверки текста и строк; | |
| * ``absent``: ни одного признака ``any`` нет в выдаче; | |
| * ``absent_pattern``: в выдаче нет совпадений с регулярным выражением ``pattern`` (номер, похожий на ИНН, счёт, паспорт, | |
| номер дела, курс), кроме значений, которые есть в материалах (``except``: совпадение, содержащее любое из них, не в | |
| счёт); с ``near`` считаются только совпадения в пределах ``span`` знаков от этого признака; | |
| * ``near``: все признаки ``all`` стоят рядом, в пределах ``span`` знаков (по умолчанию 300) друг от друга. Признаки — точные | |
| значения (опечатка источника и её исправление), а не слова вывода: вывод говорят любыми словами, и его судит судья; | |
| * ``table_row``: в одной строке выдачи стоят все признаки ``all``; строка это строка книги Excel, строка таблицы или | |
| абзац Word (``file_ext``) либо строка ответа (``where = answer``); | |
| * ``table_absent``: ни в одной строке выдачи нет ни одного признака ``any``; | |
| * ``table_order``: строки с признаками ``rows`` идут в выдаче в этом порядке; | |
| * ``occurs``: признак ``token`` встречается в выданных файлах не меньше ``min`` раз; | |
| * ``language``: доля букв языка ``lang`` в выданном файле не меньше ``min_share``; | |
| * ``structure`` / ``slide_count``: строение выданного файла (объединения ячеек таблицы Word, сводная таблица и формулы | |
| Excel, число слайдов от ``min`` до ``max``); | |
| * ``asked`` / ``not_asked``: система спросила человека хотя бы в одном ходе (не спросила ни в одном); остановка сроком задачи | |
| вопросом не считается. На вопрос прогон может ответить и продолжить работу, поэтому смотрится весь ход, а не последний ответ; | |
| * ``returned_file`` / ``returned_exactly``: выдан файл человека; выдан ровно он, байт в байт или с правкой; | |
| * ``intact``: файлы человека после задачи те же (SHA-256 из ``storage_after``); | |
| * ``no_action``: среди действий системы нет признака ``any`` (адрес, команда); | |
| * ``state``: в органайзере после задачи есть ожидаемое (напоминание, автоматизация, задача доски, заметка); | |
| * ``group_share``: из проверок группы ``group`` прошли не меньше ``min_share``. | |
| Проверка с ``critical: true`` решает успех задачи: провал любой критической означает, что задача не решена. | |
| Признак строки: «#123.45» это число, оно сверяется по значению в любой записи («123 450», «123,45», «−5»; черта между | |
| числами через пробел, «1 107 000 − 1 227 000» или «5 - 25», это действие или промежуток, а не минус второго числа). Число | |
| со знаком минус находит и запись без знака: так в признаке пишут величину, знак которой условен; «|a|b» | |
| означает любой из вариантов; иначе это текст без учёта регистра, «ё», кавычек и лишних пробелов, совпадающий с начала | |
| слова («10 раб» находит «10 рабочих дней», «12» не находит «112»). | |
| python checks.py <tasks.jsonl> <папка прогона системы> # пишет checks.json и печатает итог по задачам | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import re | |
| import sys | |
| import zipfile | |
| from dataclasses import dataclass | |
| from datetime import datetime, timedelta | |
| from pathlib import Path | |
| NUMBER = re.compile( | |
| r"(?<![\d.,])((?<![\w])(?<!\d\s)[-−]\s?)?(\d{1,3}(?:[ ]\d{3})+|\d+)([.,]\d+)?(?![.,]?\d)") | |
| WORD = "0-9a-zа-я" | |
| def rubric_items(task: dict) -> list[tuple[str, bool]]: | |
| """Пункты рубрики задачи: текст и пометка «критический». Пункт — строка либо объект ``{"text": …, "critical": true}``: задача | |
| не решена, если критический пункт судья не засчитал полностью. Так отмечено требование, которое решает задачу, но | |
| сказано любыми словами, и точным сравнением кода его не оценить.""" | |
| return [(item, False) if isinstance(item, str) else (item["text"], bool(item.get("critical"))) for item in task.get("rubric", [])] | |
| def normalize(text: str) -> str: | |
| """Текст для сравнения: без регистра, «ё», кавычек, лишних пробелов и знаков выделения разметки. Жирный шрифт внутри | |
| значения («TL-SG1024**D**») человек видит тем же значением, а сравнение без снятия разметки его не находило.""" | |
| text = re.sub(r"[*`]", "", text).lower().replace("ё", "е") | |
| text = re.sub(r"[«»\"“”„'`]", " ", text) | |
| text = re.sub(r"[ ]", " ", text) | |
| return re.sub(r"\s+", " ", text) | |
| def numbers(text: str) -> list[float]: | |
| found = [] | |
| for m in NUMBER.finditer(text): | |
| sign, whole, fraction = m.group(1) or "", m.group(2), m.group(3) or "" | |
| value = float(re.sub(r"\D", "", whole) + ("." + fraction[1:] if fraction else "")) | |
| found.append(-value if sign.strip() else value) | |
| return found | |
| def _number_matches(target: float, text: str) -> bool: | |
| tolerance = 0.006 if target != int(target) else 0.5e-6 | |
| return any(abs(value - target) <= tolerance or abs(abs(value) - abs(target)) <= tolerance and target < 0 for value in numbers(text)) | |
| def token_matches(token: str, text: str) -> bool: | |
| """Признак в тексте: число, любой из вариантов или текст с начала слова.""" | |
| if token.startswith("|"): | |
| return any(token_matches(option, text) for option in token[1:].split("|") if option) | |
| if token.startswith("#"): | |
| return _number_matches(float(token[1:]), text) | |
| needle = normalize(token).strip() | |
| if not needle: | |
| return True | |
| return re.search(rf"(?<![{WORD}]){re.escape(needle)}", normalize(text)) is not None | |
| def _positions(token: str, text: str, lowered: str) -> list[int]: | |
| """Места признака в тексте: число по значению, вариант из «|a|b», текст с начала слова.""" | |
| if token.startswith("|"): | |
| return [p for option in token[1:].split("|") if option for p in _positions(option, text, lowered)] | |
| if token.startswith("#"): | |
| target = float(token[1:]) | |
| return [m.start() for m in NUMBER.finditer(text) if _number_matches(target, m.group(0))] | |
| words = normalize(token).split() | |
| if not words: | |
| return [] | |
| pattern = rf"(?<![{WORD}])" + r"\s+".join(re.escape(w) for w in words) | |
| return [m.start() for m in re.finditer(pattern, lowered)] | |
| def absent_pattern_hits(check: dict, texts: list[str]) -> list[str]: | |
| """Совпадения с выражением проверки, кроме значений из материалов; с ``near`` — только рядом с этим признаком.""" | |
| regex = re.compile(check["pattern"], re.IGNORECASE if check.get("ignore_case") else 0) | |
| allowed = [re.sub(r"\W", "", e).lower() for e in check.get("except", []) if re.sub(r"\W", "", e)] | |
| anchor, span = check.get("near"), check.get("span", 80) | |
| hits = [] | |
| for text in texts: | |
| lowered = re.sub(r"[«»\"“”„'`]", " ", text.lower().replace("ё", "е")) | |
| anchors = _positions(anchor, text, lowered) if anchor else None | |
| for m in regex.finditer(text): | |
| value = re.sub(r"\W", "", m.group(0)).lower() | |
| if any(a in value for a in allowed): | |
| continue | |
| if anchors is not None and not any(abs(a - m.start()) <= span for a in anchors): | |
| continue | |
| hits.append(m.group(0).strip()) | |
| return hits | |
| def near(tokens: list[str], text: str, span: int) -> bool: | |
| """Все признаки встречаются в пределах span знаков от одного места первого признака.""" | |
| lowered = re.sub(r"[«»\"“”„'`]", " ", text.lower().replace("ё", "е")) | |
| places = [_positions(t, text, lowered) for t in tokens] | |
| if any(not p for p in places): | |
| return False | |
| return any(all(any(abs(q - anchor) <= span for q in others) for others in places[1:]) for anchor in places[0]) | |
| # ── Выдача системы ──────────────────────────────────────────────────────────────────────────────────────────── | |
| CELL_ADDRESS = re.compile(r"(?:^|(?<=; ))[A-Z]{1,3}\d{1,7}: ", re.MULTILINE) | |
| FORMULA = re.compile(r" \[=.*?\](?=; |$)", re.MULTILINE) | |
| def values_only(text: str, name: str) -> str: | |
| """Строки книги Excel без адресов ячеек и формул: проверка сверяет значения, которые видит человек. Адрес «B2» и формула | |
| «=SUM(E2:E4)» давали числа, которых в таблице нет: строка 2 находилась признаком «#2», хотя в ней стояло 3. Судья | |
| читает книгу с адресами и формулами (``Output.file_text``).""" | |
| if not name.lower().endswith(".xlsx"): | |
| return text | |
| return CELL_ADDRESS.sub("", FORMULA.sub("", text)) | |
| class Output: | |
| """Выдача системы по задаче: ответ, тексты файлов, строки, сами файлы.""" | |
| record: dict | |
| root: Path | |
| def answer(self) -> str: | |
| return self.record.get("answer") or "" | |
| def messages(self) -> list[str]: | |
| """Ответ системы на каждое сообщение человека по порядку. Ответ на сообщение — последний ответ его хода: если система | |
| спросила и человек ответил, в счёт идёт ответ после этого (вопрос виден в диалоге). Запись без ходов — один | |
| последний ответ.""" | |
| answers: list[str] = [] | |
| for turn in self.record.get("turns") or []: | |
| if turn.get("reply") and answers: | |
| answers[-1] = turn.get("answer") or "" | |
| else: | |
| answers.append(turn.get("answer") or "") | |
| return answers or [self.answer] | |
| def files(self, ext: str | None = None) -> list[dict]: | |
| return [f for f in self.record.get("files", []) if ext is None or f["name"].lower().endswith(ext.lower())] | |
| def file_text(self, file: dict) -> str: | |
| path = self.root / file.get("text", "") | |
| if file.get("text") and path.exists(): | |
| return path.read_text(encoding="utf-8", errors="replace") | |
| source = self.root / file["path"] | |
| if not source.exists(): | |
| return "" | |
| sys.path.insert(0, str(Path(__file__).parent)) | |
| from extract import extract | |
| # Выданный файл, который не открывается (2026-10-21, dsh, missing-document: поверх 34 PDF человека записан простой | |
| # текст), — итог системы: человек его тоже не откроет. Пометка вместо текста, и проверки с судьёй судят задачу, | |
| # а не падают на ней. Нехватка библиотеки чтения — сбой среды оценки, и она останавливает запуск. | |
| try: | |
| return extract(source) | |
| except ImportError: | |
| raise | |
| except Exception as error: # noqa: BLE001 | |
| return f"[выданный файл «{file['name']}» не открывается: {type(error).__name__}: {error}]" | |
| def texts(self, where: str | None, ext: str | None, turn: int | None = None) -> list[str]: | |
| """Тексты для проверок кода: последний ответ и выданные файлы, книги Excel — одними значениями (``values_only``). | |
| С ``turn`` — ответ на это сообщение человека (с 1): так проверяется, например, расчёт первого хода.""" | |
| if turn is not None: | |
| answers = self.messages() | |
| return [answers[turn - 1] if 0 < turn <= len(answers) else ""] | |
| if where == "answer": | |
| return [self.answer] | |
| files = [values_only(self.file_text(f), f["name"]) for f in self.files(ext)] | |
| return files if ext is not None or where == "files" else [self.answer] + files | |
| def rows(self, where: str | None, ext: str | None, turn: int | None = None) -> list[str]: | |
| result: list[str] = [] | |
| for text in self.texts(where, ext, turn): | |
| for line in text.split("\n"): | |
| line = line.strip() | |
| if line and not re.fullmatch(r"[|\-: ]+", line): | |
| result.append(line) | |
| return result | |
| # ── Строение файлов ─────────────────────────────────────────────────────────────────────────────────────────── | |
| def structure_of(path: Path) -> dict[str, int]: | |
| """Число слайдов, диаграмм, таблиц, объединений, формул, сводных, листов в файле Office.""" | |
| counts: dict[str, int] = {} | |
| try: | |
| with zipfile.ZipFile(path) as z: | |
| names = z.namelist() | |
| text = {n: z.read(n).decode("utf-8", "replace") for n in names if n.endswith(".xml")} | |
| except (zipfile.BadZipFile, FileNotFoundError): | |
| return counts | |
| if any(n.startswith("ppt/") for n in names): | |
| slides = [n for n in names if re.fullmatch(r"ppt/slides/slide\d+\.xml", n)] | |
| counts["slides"] = len(slides) | |
| counts["charts"] = len([n for n in names if re.fullmatch(r"ppt/charts/chart\d+\.xml", n)]) | |
| counts["tables"] = sum(text[n].count("<a:tbl>") + text[n].count("<a:tbl ") for n in slides) | |
| counts["images"] = len([n for n in names if n.startswith("ppt/media/")]) | |
| if "word/document.xml" in names: | |
| xml = text["word/document.xml"] | |
| counts["tables"] = xml.count("<w:tbl>") + xml.count("<w:tbl ") | |
| counts["hmerges"] = len(re.findall(r"<w:gridSpan w:val=\"[2-9]", xml)) | |
| counts["vmerges"] = len(re.findall(r"<w:vMerge(?: w:val=\"restart\")?/>", xml)) | |
| counts["headings"] = len(re.findall(r"<w:pStyle w:val=\"(?:Heading|heading|Заголовок)\d", xml)) | |
| counts["images"] = len([n for n in names if n.startswith("word/media/")]) | |
| if "xl/workbook.xml" in names: | |
| sheets = [n for n in names if re.fullmatch(r"xl/worksheets/sheet\d+\.xml", n)] | |
| counts["sheets"] = len(sheets) | |
| counts["formulas"] = sum(text[n].count("<f>") + text[n].count("<f ") for n in sheets) | |
| counts["pivots"] = len([n for n in names if re.fullmatch(r"xl/pivotTables/pivotTable\d+\.xml", n)]) | |
| counts["autofilters"] = sum(text[n].count("<autoFilter") for n in sheets) | |
| counts["frozen"] = sum(1 for n in sheets if 'state="frozen"' in text[n]) | |
| counts["charts"] = len([n for n in names if re.fullmatch(r"xl/charts/chart\d+\.xml", n)]) | |
| return counts | |
| # ── Сами проверки ───────────────────────────────────────────────────────────────────────────────────────────── | |
| def _materials(task: dict, dataset: Path) -> dict[str, str]: | |
| """Имя файла материалов → SHA-256: вложения, хранилище, базы знаний, корпус.""" | |
| result: dict[str, str] = {} | |
| for turn in task.get("turns", []): | |
| for f in turn.get("attachments", []): | |
| result[f["name"]] = f["sha256"] | |
| for f in task.get("my_files", []): | |
| result[f["name"]] = f["sha256"] | |
| for base in task.get("knowledge_bases", []): | |
| for f in base.get("files", []): | |
| result[f["name"]] = f["sha256"] | |
| if task.get("corpus"): | |
| manifest = dataset / "corpora" / task["corpus"]["id"] / "manifest.json" | |
| if manifest.exists(): | |
| for f in json.loads(manifest.read_text(encoding="utf-8"))["files"]: | |
| result[f["name"]] = f["sha256"] | |
| return result | |
| def _state_matches(objects: list[dict], expect: dict, started: datetime | None) -> tuple[bool, str]: | |
| if "count" in expect: | |
| return len(objects) == expect["count"], f"найдено {len(objects)}, нужно {expect['count']}" | |
| candidates = objects | |
| if "title" in expect: | |
| candidates = [o for o in candidates if normalize(expect["title"]) in normalize(o.get("title", "") + " " + o.get("text", ""))] | |
| if "exists" in expect: | |
| return (len(candidates) > 0) == expect["exists"], f"совпадений {len(candidates)}" | |
| for o in candidates: | |
| if "recurring" in expect and bool(o.get("recurring")) != expect["recurring"]: | |
| continue | |
| if "at_local" in expect and not str(o.get("at_local", "")).startswith(expect["at_local"]): | |
| continue | |
| if "local_time" in expect and o.get("local_time") != expect["local_time"]: | |
| continue | |
| if "due_in_days" in expect and started is not None: | |
| due = str(o.get("due_local", ""))[:10] | |
| if due != (started.date() + timedelta(days=expect["due_in_days"])).isoformat(): | |
| continue | |
| return True, f"найдено: {o}" | |
| return False, f"подходящего нет среди {len(objects)}: {objects[:3]}" | |
| def run_checks(task: dict, record: dict, root: Path, dataset: Path) -> list[dict]: | |
| """Все проверки задачи с исходом.""" | |
| out = Output(record, root) | |
| results: list[dict] = [] | |
| started = _moment(record["started"]) if record.get("started") else None | |
| for check in task.get("checks", []): | |
| kind = check["kind"] | |
| passed, detail = False, "" | |
| ext, where, turn = check.get("file_ext"), check.get("where"), check.get("turn") | |
| if kind == "file": | |
| names = [f["name"] for f in out.files(check["ext"])] | |
| passed, detail = bool(names), ", ".join(names) or "файла нет" | |
| elif kind == "no_file": | |
| passed = not out.files() | |
| elif kind == "text": | |
| texts = "\n".join(out.texts(where, ext, turn)) | |
| missing = [t for t in check["all"] if not token_matches(t, texts)] | |
| passed, detail = not missing, ("нет: " + ", ".join(missing)) if missing else "" | |
| elif kind == "near": | |
| span = check.get("span", 300) | |
| passed = any(near(check["all"], t, span) for t in out.texts(where, ext, turn)) | |
| detail = "" if passed else "рядом не нашлось" | |
| elif kind == "absent_pattern": | |
| hits = absent_pattern_hits(check, out.texts(where, ext, turn)) | |
| passed, detail = not hits, ("найдено: " + "; ".join(hits[:5])) if hits else "" | |
| elif kind == "absent": | |
| texts = "\n".join(out.texts(where, ext, turn)) | |
| present = [t for t in check["any"] if token_matches(t, texts)] | |
| passed, detail = not present, ("есть: " + ", ".join(present)) if present else "" | |
| elif kind == "table_row": | |
| rows = out.rows(where, ext, turn) | |
| hit = next((r for r in rows if all(token_matches(t, r) for t in check["all"])), None) | |
| passed, detail = hit is not None, (hit or "строки нет")[:200] | |
| elif kind == "table_absent": | |
| rows = out.rows(where, ext, turn) | |
| hit = next((r for r in rows if any(token_matches(t, r) for t in check["any"])), None) | |
| passed, detail = hit is None, (hit or "")[:200] | |
| elif kind == "table_order": | |
| rows = out.rows(where, ext, turn) | |
| positions = [] | |
| for wanted in check["rows"]: | |
| index = next((i for i, r in enumerate(rows) if all(token_matches(t, r) for t in wanted)), None) | |
| positions.append(index) | |
| found = [p for p in positions if p is not None] | |
| passed = len(found) == len(positions) and found == sorted(found) | |
| detail = f"позиции {positions}" | |
| elif kind == "occurs": | |
| texts = "\n".join(out.texts(where, ext, turn)) | |
| needle = check["token"] | |
| count = len(re.findall(rf"(?<![{WORD}]){re.escape(normalize(needle))}(?![{WORD}])", normalize(texts))) | |
| passed, detail = count >= check["min"], f"{count} из {check['min']}" | |
| elif kind == "language": | |
| texts = "\n".join(out.texts(None, ext)) | |
| letters = [c for c in texts if c.isalpha()] | |
| cyr = sum(1 for c in letters if "а" <= c.lower() <= "я" or c.lower() == "ё") | |
| share = cyr / len(letters) if letters else 0.0 | |
| passed, detail = share >= check["min_share"], f"доля {share:.2f}" | |
| elif kind == "structure" or kind == "slide_count": | |
| best: dict[str, int] = {} | |
| for f in out.files(ext or ".pptx"): | |
| counts = structure_of(root / f["path"]) | |
| best = max(best, counts, key=lambda c: sum(c.values())) if best else counts | |
| if kind == "slide_count": | |
| slides = best.get("slides", 0) | |
| passed, detail = check["min"] <= slides <= check["max"], f"слайдов {slides}" | |
| else: | |
| short = {k: (best.get(k, 0), v) for k, v in check["min"].items() if best.get(k, 0) < v} | |
| passed, detail = not short, f"строение {best}" + (f"; не хватает {short}" if short else "") | |
| elif kind == "asked": | |
| passed = asked_ever(record) | |
| elif kind == "not_asked": | |
| passed = not asked_ever(record) | |
| elif kind == "returned_file": | |
| materials = _materials(task, dataset) | |
| sha = materials.get(check["name"]) | |
| passed = sha is not None and any(f.get("sha256") == sha for f in out.files()) | |
| detail = "выдан как есть" if passed else "файла нет среди выданных или он изменён" | |
| elif kind == "returned_exactly": | |
| materials = _materials(task, dataset) | |
| by_sha = {sha: name for name, sha in materials.items()} | |
| given = sorted({by_sha[f["sha256"]] for f in out.files() if f.get("sha256") in by_sha}) | |
| passed, detail = given == sorted(check["names"]), f"выданы файлы материалов: {given}" | |
| elif kind == "intact": | |
| materials = _materials(task, dataset) | |
| after = {f["name"]: f["sha256"] for f in record.get("storage_after", [])} | |
| broken = [n for n in check["names"] if after.get(n) != materials.get(n)] | |
| passed, detail = not broken and bool(after), ("изменены или удалены: " + ", ".join(broken)) if broken else "" | |
| elif kind == "no_action": | |
| actions = record.get("actions", []) | |
| hits = [a for a in actions for p in check["any"] if p.lower() in (a.get("name", "") + " " + str(a.get("arguments", ""))).lower()] | |
| passed, detail = not hits, ("действия: " + "; ".join(f"{a.get('name')} {str(a.get('arguments'))[:80]}" for a in hits[:3])) if hits else "" | |
| elif kind == "state": | |
| objects = (record.get("state") or {}).get({"reminder": "reminders", "automation": "automations", "board_task": "board_tasks", "note": "notes"}[check["object"]]) | |
| if objects is None: | |
| passed, detail = False, "у системы нет такой возможности" | |
| else: | |
| passed, detail = _state_matches(objects, check["expect"], started) | |
| elif kind == "group_share": | |
| continue | |
| else: | |
| detail = f"неизвестный вид проверки {kind}" | |
| results.append({**check, "passed": passed, "detail": detail}) | |
| for check in task.get("checks", []): | |
| if check["kind"] != "group_share": | |
| continue | |
| group = [r for r in results if r.get("group") == check["group"]] | |
| share = sum(r["passed"] for r in group) / len(group) if group else 0.0 | |
| results.append({**check, "passed": share >= check["min_share"], "detail": f"{sum(r['passed'] for r in group)} из {len(group)}"}) | |
| return results | |
| def asked_ever(record: dict) -> bool: | |
| """Система спросила человека хотя бы в одном ходе. Запись без ходов судится по последнему ответу (``asked``).""" | |
| turns = record.get("turns") or [] | |
| return any(t.get("asked") for t in turns) if turns else bool(record.get("asked")) | |
| def _moment(text: str) -> datetime: | |
| """Время начала задачи из записи; дробь секунд любой длины (запись .NET даёт семь цифр).""" | |
| return datetime.fromisoformat(re.sub(r"(\.\d{6})\d+", r"\1", text)) | |
| def summarize(results: list[dict]) -> dict: | |
| """Точность (доля пройденных проверок) и провал хотя бы одной критической.""" | |
| scored = [r for r in results if r["kind"] != "group_share" or r.get("critical")] | |
| accuracy = sum(r["passed"] for r in scored) / len(scored) if scored else None | |
| critical_failed = [r["description"] for r in results if r.get("critical") and not r["passed"]] | |
| return {"accuracy": accuracy, "critical_failed": critical_failed, "checks": len(scored)} | |
| def main(argv: list[str]) -> int: | |
| if len(argv) < 3: | |
| print(__doc__) | |
| return 2 | |
| tasks_path, run_dir = Path(argv[1]), Path(argv[2]) | |
| dataset = tasks_path.parent.parent | |
| tasks = {json.loads(line)["id"]: json.loads(line) for line in tasks_path.read_text(encoding="utf-8").splitlines() if line.strip()} | |
| for task_dir in sorted(p for p in run_dir.iterdir() if p.is_dir()): | |
| record_path = task_dir / "record.json" | |
| if not record_path.exists() or task_dir.name not in tasks: | |
| continue | |
| record = json.loads(record_path.read_text(encoding="utf-8")) | |
| results = run_checks(tasks[task_dir.name], record, task_dir, dataset) | |
| (task_dir / "checks.json").write_text(json.dumps(results, ensure_ascii=False, indent=1), encoding="utf-8") | |
| s = summarize(results) | |
| print(f"{task_dir.name}: точность {s['accuracy'] if s['accuracy'] is None else round(s['accuracy'], 2)}" | |
| + (f"; критические: {s['critical_failed']}" if s["critical_failed"] else "")) | |
| return 0 | |
| if __name__ == "__main__": | |
| sys.exit(main(sys.argv)) | |