Blame for eval/checks.py

"""Проверки кодом: то, что в выдаче системы можно сверить без модели.



Вход: строка задачи из ``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))


@dataclass
class Output:
    """Выдача системы по задаче: ответ, тексты файлов, строки, сами файлы."""

    record: dict
    root: Path

    @property
    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))