---

сцен
                        cell_value = section_row.cells.get(column_name)
                        duration_text = (section_row.cells.get(column_name) or "").strip() or MtReportConst.ZERO_DURATION_TEXT
                        StepCheck(
                            f"Участок '{section_row.section_name}': колонка '{column_name}'",
                            "длительность",
                            soft_failures,
                        ).actual(mt_report_utils.is_duration_cell_filled(cell_value)).is_true_with_details(
                            expected_text="указано время в формате H:MM:SS (допускается 0:00:00)",
                            actual_text=duration_text,
                        )

                total_duration_text = (
                    parsed_report.total_duration_raw
                    or lds_report_utils.format_duration_seconds(total_duration_seconds or 0)
                )
                total_label_row = parsed_report.total_label_row_index
                StepCheck(
                    "В отчёте присутствует строка 'Суммарное время работы:'",
                    "структура отчёта",
                    soft_failures,
                ).actual(total_label_row is not None).is_true_with_details(
                    expected_text=f"найдена строка с текстом '{MtReportConst.TOTAL_WORK_DURATION_LABEL}'",
                    actual_text=(
                        f"строка {total_label_row} содержит '{MtReportConst.TOTAL_WORK_DURATION_LABEL}'"
                        if total_label_row is not None
                        else "строка не найдена"
                    ),
                )
                StepCheck(
                    "Суммарное время работы в отчёте больше нуля",
                    "суммарное время",
                    soft_failures,
                ).actual((total_duration_seconds or 0) > 0).is_true_with_details(
                    expected_text="суммарное время больше 0:00:00",
                    actual_text=total_duration_text,
                )

                for section_row in section_rows:
                    duration_diff = abs(section_row.modes_sum_seconds - (total_duration_seconds or 0))
                    section_sum_text = lds_report_utils.format_duration_seconds(section_row.modes_sum_seconds)
                    diff_text = lds_report_utils.format_duration_seconds(duration_diff)
                    sums_match = duration_diff < duration_tolerance + 1
                    StepCheck(
                        f"Участок '{section_row.section_name}': сумма режимов МТ совпадает с общим временем "
                        f"(±{duration_tolerance} с)",
                        "согласованность длительностей",
                        soft_failures,
                    ).actual(sums_match).is_true_with_details(
                        expected_text=(
                            f"сумма режимов ({section_sum_text}) равна суммарному времени ({total_duration_text}), "
                            f"погрешность не более {duration_tolerance} с"
                        ),
                        actual_text=(
                            f"сумма режимов: {section_sum_text}, суммарное время: {total_duration_text}, "
                            f"разница: {diff_text} ({duration_diff} с)"
                        ),
                    )

                dominant_column = report_state.expected_dominant_mode_column
                dominant_total = mode_totals.get(dominant_column, 0)
                max_column = max(mode_totals, key=mode_totals.get)
                max_total = mode_totals[max_column]
                all_modes_text = ", ".join(
                    f"'{column_name}': {lds_report_utils.format_duration_seconds(total_seconds)}"
                    for column_name, total_seconds in mode_totals.items()
                )
                StepCheck(
                    f"Режим '{dominant_column}' имеет максимальное суммарное время по всем участкам",
                    "доминирующий режим МТ",
                    soft_failures,
                ).actual(
                    mt_report_utils.is_expected_dominant_mode_column(mode_totals, dominant_column)
                ).is_true_with_details(
                    expected_text=(
                        f"'{dominant_column}': {lds_report_utils.format_duration_seconds(dominant_total)} - "
                        f"наибольшее время; по всем участкам: {all_modes_text}"
                    ),
                    actual_text=(
                        f"наибольшее время у режима '{max_column}': "
                        f"{lds_report_utils.format_duration_seconds(max_total)}"
                    ),
                )
                allure.attach(
                    "\n".join(
                        f"{column_name}: {lds_report_utils.format_duration_seconds(total_seconds)}"
                        for column_name, total_seconds in mode_totals.items()
                    ),
                    name="Суммарные длительности режимов МТ по всем участкам",
                    attachment_type=allure.attachment_type.TEXT,
                )

        with allure.step("Проверка диаграммы режимов МТ"):
            chart_formula = parsed_report.chart_series_formula or "(формула не найдена)"
            with SoftAssertions() as soft_failures:
                StepCheck(
                    f"Заголовок диаграммы в ячейке F{MtReportConst.CHART_TITLE_ROW}",
                    "заголовок диаграммы",
                    soft_failures,
                ).actual(
                    mt_report_utils.is_chart_title_valid(
                        parsed_report.chart_title_raw,
                        cfg.technological_unit.description,
                    )
                ).is_true_with_details(
                    expected_text=(
                        f"содержит '{MtReportConst.CHART_TITLE_PREFIX}' "
                        f"и название ТУ '{cfg.technological_unit.description}'"
                    ),
                    actual_text=parsed_report.chart_title_raw.replace("\n", " / ") or "(пусто)",
                )
                StepCheck(
                    f"Диаграмма построена по данным листа '{MtReportConst.CHART_DATA_SHEET_NAME}' "
                    f"(ожидается формула SERIES в I{MtReportConst.CHART_FORMULA_ROW})",
                    "источник данных диаграммы",
                    soft_failures,
                ).actual(
                    mt_report_utils.is_valid_mt_mode_chart_series_formula(parsed_report.chart_series_formula)
                ).is_true_with_details(
                    expected_text=(
                        f"в ячейке I{MtReportConst.CHART_FORMULA_ROW} задана формула SERIES (или РЯД), "
                        f"которая ссылается на категории {MtReportConst.CHART_CATEGORY_RANGE} "
                        f"и значения {MtReportConst.CHART_VALUES_RANGE} листа '{MtReportConst.CHART_DATA_SHEET_NAME}'"
                    ),
                    actual_text=chart_formula,
                )

        with allure.step("Подготовка данных шапки отчёта для проверки"):







utils/helpers/asserts.py

    def is_less_than(self, threshold: Any, extra_info: Any = None) -> None:
        """Проверка, что значение меньше порога"""
        if self._actual is None:
            raise ValueError("Фактический результат должен быть заполнен при вызове is_less_than()")

        msg = self._msg_builder.is_less_than_msg(threshold, self._actual, extra_info)

        try:
            with allure.step(msg):
                assert_that(self._actual).described_as(msg).is_less_than(threshold)
        except AssertionError as exc:
            self._handle_assertion(exc)

    def is_true_with_details(self, expected_text: str, actual_text: str) -> None:
        """Проверка булева условия с описанием ожидания и факта."""
        if self._actual is None:
            raise ValueError("Фактический результат должен быть заполнен при вызове is_true_with_details()")

        message_parts = [
            f"Ожидаемый результат: {expected_text}",
            f"Фактический результат: {actual_text}",
        ]
        msg = self._msg_builder._build_message(message_parts)

        try:
            with allure.step(msg):
                assert_that(self._actual).described_as(msg).is_true()
        except AssertionError as exc:
            self._handle_assertion(exc)

















utils/helpers/mt_mode_report_xlsx_utils.py
"""
Утилиты для разбора xlsx-отчёта о режиме работы МТ.
"""

from __future__ import annotations

from dataclasses import dataclass, field
from pathlib import Path
from typing import Dict, List, Optional

from openpyxl.worksheet.worksheet import Worksheet

from constants.test_constants import ExportMtModeReportConstants as MtReportConst
from utils.helpers.lds_status_report_xlsx_utils import (
    find_total_work_duration,
    format_duration_seconds,
    is_duration_cell_filled,
    parse_duration_seconds,
)
from utils.helpers.report_xlsx_utils import (
    ReportTitleInfo,
    _stringify_cell,
    build_column_cells,
    get_report_column_headers,
    parse_report_title,
    read_worksheet_cell_formula,
    read_worksheet_cell_value,
    sum_duration_columns_across_rows,
)


@dataclass
class MtModeReportSectionRow:
    """Строка участка с длительностями режимов МТ."""

    row_index: int
    section_name: str
    cells: Dict[str, str] = field(default_factory=dict)

    @property
    def mode_durations_seconds(self) -> Dict[str, int]:
        """Длительности режимов МТ в секундах по колонкам отчёта."""
        return {
            column_name: parse_duration_seconds(self.cells.get(column_name)) or 0
            for column_name in MtReportConst.MODE_DURATION_COLUMNS
        }

    @property
    def modes_sum_seconds(self) -> int:
        """Сумма длительностей всех режимов МТ для участка."""
        return sum(self.mode_durations_seconds.values())


@dataclass
class MtModeReportParsed:
    """Разобранный отчёт о режиме работы МТ."""

    title_info: ReportTitleInfo
    column_headers: List[str]
    section_rows: List[MtModeReportSectionRow]
    total_duration_seconds: Optional[int] = None
    total_duration_raw: str = ""
    total_label_row_index: Optional[int] = None
    chart_title_raw: str = ""
    chart_series_formula: str = ""


def _find_mt_mode_chart_series_formula(source_file_path: Path) -> str:
    """Ищет формулу SERIES/РЯД: сначала в I3, затем по всем ячейкам листа xlsx."""
    formula = read_worksheet_cell_formula(
        source_file_path,
        MtReportConst.CHART_FORMULA_ROW,
        MtReportConst.CHART_FORMULA_COLUMN,
    )
    if is_valid_mt_mode_chart_series_formula(formula):
        return formula

    if not source_file_path.exists():
        return ""

    workbook = None
    try:
        from openpyxl import load_workbook

        workbook = load_workbook(filename=str(source_file_path), read_only=False, data_only=False)
        for worksheet in workbook.worksheets:
            for row in worksheet.iter_rows():
                for cell in row:
                    value = cell.value
                    if isinstance(value, str) and is_valid_mt_mode_chart_series_formula(value):
                        return value
    except Exception:
        return ""
    finally:
        if workbook is not None:
            workbook.close()

    return ""


def read_mt_mode_chart_metadata(source_file_path: Path) -> tuple[str, str]:
    """
    Читает заголовок (F2) и формулу диаграммы (I3 или первую подходящую SERIES/РЯД в листе xlsx).
    """
    chart_title_value = read_worksheet_cell_value(
        source_file_path,
        MtReportConst.CHART_TITLE_ROW,
        MtReportConst.CHART_TITLE_COLUMN,
        data_only=True,
    )
    chart_title_raw = _stringify_cell(chart_title_value)
    chart_series_formula = _find_mt_mode_chart_series_formula(source_file_path)
    return chart_title_raw, chart_series_formula


def is_valid_mt_mode_chart_series_formula(formula: str) -> bool:
    """Проверяет, что в ячейке диаграммы задана формула SERIES/РЯД с ожидаемыми диапазонами."""
    if not formula.startswith("="):
        return False

    formula_normalized = formula.replace(" ", "")
    formula_upper = formula_normalized.upper()
    has_series_function = formula_upper.startswith("=SERIES(") or formula_normalized.startswith("=РЯД(")
    if not has_series_function:
        return False

    required_fragments = (
        MtReportConst.CHART_DATA_SHEET_NAME,
        MtReportConst.CHART_CATEGORY_RANGE,
        MtReportConst.CHART_VALUES_RANGE,
    )
    return all(fragment in formula for fragment in required_fragments)


def is_chart_title_valid(chart_title_raw: str, tu_description: str) -> bool:
    """Проверяет заголовок диаграммы: префикс режима МТ и название ТУ."""
    return MtReportConst.CHART_TITLE_PREFIX in chart_title_raw and tu_description in chart_title_raw


def is_expected_dominant_mode_column(mode_totals: Dict[str, int], expected_column: str) -> bool:
    """
    Проверяет, что суммарное время ожидаемого режима строго максимально и больше нуля.

    Не допускает «мягкую» проверку <=, чтобы не пропустить ничью с другим режимом.
    """
    expected_total = mode_totals.get(expected_column, 0)
    if expected_total <= 0:
        return False
    return expected_total == max(mode_totals.values())


def parse_mt_mode_report_worksheet(
    worksheet: Worksheet,
    expected_section_names: List[str],
    *,
    source_file_path: Optional[Path] = None,
) -> MtModeReportParsed:
    """
    Разбирает лист xlsx-отчёта о режиме МТ: шапка, колонки, строки участков и суммарное время.

    В section_rows попадают только участки из expected_section_names (без учёта регистра).
    Метаданные диаграммы читаются из source_file_path отдельно (формула требует data_only=False).
    """
    headers = get_report_column_headers(worksheet, MtReportConst.REPORT_COLUMN_HEADERS_ROW)
    title_info = parse_report_title(
        worksheet.cell(row=MtReportConst.REPORT_TITLE_ROW, column=1).value,
        MtReportConst.REPORT_HEADER_PERIOD_PATTERN,
    )
    total_duration_seconds, total_duration_raw, total_label_row_index = find_total_work_duration(
        worksheet,
        data_first_row=MtReportConst.REPORT_DATA_FIRST_ROW,
        total_work_duration_label=MtReportConst.TOTAL_WORK_DURATION_LABEL,
    )

    section_rows: List[MtModeReportSectionRow] = []
    expected_names_lower = {name.lower() for name in expected_section_names}

    for row_index, row_values in enumerate(
        worksheet.iter_rows(
            min_row=MtReportConst.REPORT_DATA_FIRST_ROW,
            max_col=len(headers) if headers else 5,
            values_only=True,
        ),
        start=MtReportConst.REPORT_DATA_FIRST_ROW,
    ):
        if total_label_row_index is not None and row_index >= total_label_row_index:
            break

        cells = build_column_cells(row_values, headers)
        section_name = cells.get(MtReportConst.COL_SECTION, "").strip()
        if not section_name:
            continue
        if section_name.lower() not in expected_names_lower:
            continue

        section_rows.append(
            MtModeReportSectionRow(
                row_index=row_index,
                section_name=section_name,
                cells=cells,
            )
        )

    chart_title_raw = ""
    chart_series_formula = ""
    if source_file_path is not None:
        chart_title_raw, chart_series_formula = read_mt_mode_chart_metadata(source_file_path)

    return MtModeReportParsed(
        title_info=title_info,
        column_headers=headers,
        section_rows=section_rows,
        total_duration_seconds=total_duration_seconds,
        total_duration_raw=total_duration_raw,
        total_label_row_index=total_label_row_index,
        chart_title_raw=chart_title_raw,
        chart_series_formula=chart_series_formula,
    )


def format_mt_mode_section_rows_for_allure(section_rows: List[MtModeReportSectionRow]) -> str:
    """Форматирует строки участков отчёта о режиме МТ для вложения в Allure."""
    lines = []
    for row in section_rows:
        durations_text = ", ".join(
            f"{column}={format_duration_seconds(seconds)}"
            for column, seconds in row.mode_durations_seconds.items()
        )
        lines.append(
            f"row#{row.row_index}: {row.section_name} | sum={format_duration_seconds(row.modes_sum_seconds)} | "
            f"{durations_text}"
        )
    return "\n".join(lines)


format_section_rows_for_allure = format_mt_mode_section_rows_for_allure


__all__ = [
    "MtModeReportParsed",
    "MtModeReportSectionRow",
    "is_chart_title_valid",
    "is_duration_cell_filled",
    "is_expected_dominant_mode_column",
    "is_valid_mt_mode_chart_series_formula",
    "parse_mt_mode_report_worksheet",
    "read_mt_mode_chart_metadata",
    "format_mt_mode_section_rows_for_allure",
    "format_section_rows_for_allure",
    "sum_duration_columns_across_rows",
]

















utils/helpers/report_xlsx_utils.py
    return worksheet.cell(row=row, column=column).value


def read_worksheet_cell_formula(
    file_path: Path,
    row: int,
    column: int,
    *,
    sheet_index: int = ReportConst.DEFAULT_SHEET_INDEX,
) -> str:
    """
    Читает формулу ячейки из xlsx.

    read_only-режим openpyxl не возвращает формулы, поэтому загрузка выполняется
    с read_only=False и data_only=False.
    """
    if not file_path.exists():
        return ""
    workbook = None
    try:
        workbook = load_workbook(filename=str(file_path), read_only=False, data_only=False)
        sheet_names = workbook.sheetnames
        if not sheet_names:
            return ""
        worksheet = workbook[sheet_names[sheet_index]]
        value = worksheet.cell(row=row, column=column).value
        return value if isinstance(value, str) else ""
    except Exception:
        return ""
    finally:
        if workbook is not None:
            workbook.close()