CodSpeed regression: highspy 1.15.0 addRows ~4x slower in direct HiGHS handoff (#809 bump)

# /// script
# requires-python = ">=3.12,<3.13"
# dependencies = [
#     "linopy",
#     "pytest",
#     "pytest-benchmark",
#     "pytest-benchmem",  # memory companion (memray peak pass): shows #814
# ]
# ///
"""Reproduce the HiGHS handoff slowdown -- linopy-native, runnable via uv.

Mirrors the CI benchmark ``test_to_solver[highs-sparse_network-n=250]``: build
the linopy model, then hand it to HiGHS through pytest-benchmark's ``benchmark``
fixture. No manual timing, no hand-built matrices. highspy is the variable under
test, injected per run so both versions share an identical (locked) env:

    # time only (matches CI / CodSpeed WallTime)
    uv run --locked --with highspy==1.13.1 highs_handoff_bench.py --benchmark-columns=median,mean
    uv run --locked --with highspy==1.15.0 highs_handoff_bench.py --benchmark-columns=median,mean

    # time + peak memory (pytest-benchmem, via memray) -- shows #814 too
    uv run --locked --with highspy==1.15.0 highs_handoff_bench.py --benchmark-memory

Regenerate the lock with:  uv lock --script highs_handoff_bench.py
"""

from __future__ import annotations

import sys

import numpy as np
import pandas as pd
import pytest
import xarray as xr

import linopy


def build_sparse_network(n_buses: int = 250) -> linopy.Model:
    """The ``sparse_network`` benchmark: a ring network flow balance.

    ``flow * incidence`` broadcasts against a dense bus x line block -- ordinary
    linopy modelling, and the reason the constraint matrix fills with zeros.
    """
    rng = np.random.default_rng(42)
    n_lines = n_buses
    n_time = min(n_buses, 24)
    buses = pd.RangeIndex(n_buses, name="bus")
    lines = pd.RangeIndex(n_lines, name="line")
    time_ = pd.RangeIndex(n_time, name="time")

    bus_from = np.arange(n_lines)
    bus_to = (bus_from + 1) % n_buses

    m = linopy.Model()
    gen = m.add_variables(lower=0, coords=[buses, time_], name="gen")
    flow = m.add_variables(lower=-100, upper=100, coords=[lines, time_], name="flow")

    incidence = np.zeros((n_buses, n_lines))
    incidence[bus_to, np.arange(n_lines)] = 1
    incidence[bus_from, np.arange(n_lines)] = -1
    incidence_da = xr.DataArray(incidence, coords=[buses, lines])

    demand = xr.DataArray(rng.uniform(10, 100, size=(n_buses, n_time)), coords=[buses, time_])
    net_flow = (flow * incidence_da).sum("line")
    m.add_constraints(gen + net_flow == demand, name="balance")
    m.add_objective(gen.sum())
    return m


@pytest.fixture(scope="module")
def model() -> linopy.Model:
    m = build_sparse_network(250)
    A = m.matrices.A  # trigger + report the explicit-zero fill (#814)
    zeros = A.nnz - int(np.count_nonzero(A.data))
    print(
        f"\nmatrices.A rows={A.shape[0]} cols={A.shape[1]} "
        f"stored_nnz={A.nnz} structural_nnz={A.nnz - zeros} "
        f"({100 * zeros / A.nnz:.1f}% explicit zeros)"
    )
    return m


def test_to_highspy(benchmark, model: linopy.Model) -> None:
    benchmark(lambda: linopy.io.to_highspy(model))


if __name__ == "__main__":
    # Run this file as its own pytest session; ``-o addopts=`` drops any config
    # inherited from a surrounding repo so the script is self-contained.
    raise SystemExit(
        pytest.main(
            [__file__, "-q", "--benchmark-only", "-o", "addopts=", "-p", "no:cacheprovider", *sys.argv[1:]]
        )
    )