"""
Цена `is` против цены `==` для урока «is против ==».

ЗАПУСК (числа урока сняты на 3.13.7):

    python3.13 bench/identity/cost.py
    python3.14 bench/identity/cost.py

ЧТО МОЖНО СРАВНИВАТЬ. Только строки одного запуска между собой. Абсолютные
наносекунды с другой машины несравнимы, между версиями — тоже (общее правило
замеров про тулчейн).

ПОЧЕМУ ЗАМЕР БЕЗ ЦИКЛА. Первая версия ставила сравнение внутрь `for`, и
разница утонула: на каждое сравнение приходились ещё итерация и проверка
границы, то есть мерился в основном цикл. Здесь тело — двести одинаковых
сравнений подряд, отдельными строками; накладной расход на них — это две
загрузки имени, одинаковые во всех строках таблицы.

ЧТО ЭТИ ЧИСЛА ЗНАЧАТ. Ровно одно: `is` не зависит ни от типа, ни от размера
объекта, потому что это сравнение адресов, а `==` зависит и от того, и от
другого. Вывода «пишите is вместо ==» отсюда НЕ следует: это разные вопросы, и
там, где нужен `==`, `is` даёт неверный ответ быстро.
"""

import sys
import timeit

REPEATS_IN_BODY = 200


def header(title: str) -> None:
    print(f"\n--- {title} ---")


def ns(stmt: str, env: dict, number: int) -> float:
    """Наносекунды на одно сравнение: минимум из семи повторов."""
    body = (stmt + "\n") * REPEATS_IN_BODY
    best = min(timeit.repeat(body, globals=env, number=number, repeat=7))
    return best / (number * REPEATS_IN_BODY) * 1e9


class Plain:
    """Без своего __eq__: сравнение падает обратно на тождество."""

    def __init__(self, value: int) -> None:
        self.value = value


class WithEq(Plain):
    """Со своим __eq__ на Python."""

    def __eq__(self, other: object) -> bool:
        return isinstance(other, Plain) and self.value == other.value

    __hash__ = None  # type: ignore[assignment]


def build_env() -> dict:
    # Строки собираются во время выполнения: литералы компилятор объединил бы
    # в один объект, и сравнение по is стало бы сравнением объекта с собой.
    short_a = "".join(["a"] * 200)
    short_b = "".join(["a"] * 200)
    assert short_a is not short_b and short_a == short_b

    long_a = "".join(["a"] * 200_000)
    long_b = "".join(["a"] * 200_000)
    assert long_a is not long_b and long_a == long_b

    early = "b" + "a" * 199

    big_a = int("1" + "0" * 40)
    big_b = int("1" + "0" * 40)
    assert big_a is not big_b

    return {
        "p1": Plain(1),
        "p2": Plain(1),
        "e1": WithEq(1),
        "e2": WithEq(1),
        "short_a": short_a,
        "short_b": short_b,
        "long_a": long_a,
        "long_b": long_b,
        "early": early,
        "big_a": big_a,
        "big_b": big_b,
    }


def bench() -> None:
    env = build_env()

    header("1. is не зависит от того, что сравнивается")
    rows = [
        ("объект без __eq__", "p1 is p2", 20000),
        ("строка 200 символов", "short_a is short_b", 20000),
        ("строка 200 000 символов", "long_a is long_b", 20000),
        ("большое число", "big_a is big_b", 20000),
    ]
    for name, stmt, number in rows:
        print(f"{name:<26} {ns(stmt, env, number):>8.2f} нс")

    header("2. == зависит и от типа, и от размера")
    rows = [
        ("объект без __eq__", "p1 == p2", 20000),
        ("объект со своим __eq__", "e1 == e2", 20000),
        ("строки 200, равные", "short_a == short_b", 20000),
        ("строки 200, разные с 1-го символа", "short_a == early", 20000),
        ("строки 200 000, равные", "long_a == long_b", 2000),
        ("большие числа, равные", "big_a == big_b", 20000),
    ]
    for name, stmt, number in rows:
        print(f"{name:<36} {ns(stmt, env, number):>9.2f} нс")

    header("3. Как цена растёт по длине")
    print(f"{'длина строки':>14} {'is, нс':>10} {'==, нс':>12}")
    for size in (200, 2_000, 20_000, 200_000):
        left = "".join(["a"] * size)
        right = "".join(["a"] * size)
        assert left is not right and left == right
        pair = {"left": left, "right": right}
        number = 20000 if size <= 20_000 else 2000
        print(
            f"{size:>14} "
            f"{ns('left is right', pair, 20000):>10.2f} "
            f"{ns('left == right', pair, number):>12.2f}"
        )
    print("\nis не меняется вовсе: это сравнение двух адресов.")
    print("== обязан дочитать до первого различия, а у равных строк его нет.")

    header("4. Во сколько раз")
    identity = ns("long_a is long_b", env, 20000)
    equality = ns("long_a == long_b", env, 2000)
    print(f"строка 200 000: == дороже is в {equality / identity:.0f} раз")
    py_eq = ns("e1 == e2", env, 20000)
    base = ns("p1 is p2", env, 20000)
    print(f"свой __eq__ на Python: дороже is в {py_eq / base:.1f} раза")


def main() -> None:
    print(f"Python {sys.version.split()[0]}")
    bench()


if __name__ == "__main__":
    main()