"""
Наблюдения для урока «is против ==».

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

    for v in 3.11 3.12 3.13 3.14; do python$v bench/identity/traps.py; done

ЗДЕСЬ НЕТ ЗАМЕРОВ ВРЕМЕНИ. Скрипт печатает ответы на вопрос «один это объект
или два», то есть `is`. Такие ответы от машины не зависят. Время меряется
отдельно, в `cost.py`.

ПОЧЕМУ ВЕЗДЕ int(str(v)), А НЕ ПРОСТО ЛИТЕРАЛ. Литерал в исходнике —
константа, и компилятор объединяет равные константы в пределах одного файла;
`1000 is 1000` в исходнике даст True не из-за кеша чисел, а из-за этого
объединения. Чтобы мерить кеш, а не компилятор, числа строятся во время
выполнения — из строки, которую компилятор посчитать заранее не может.

ЧЕГО ЭТОТ СКРИПТ НЕ ДОКАЗЫВАЕТ. Что на эти ответы можно опираться в коде.
Ровно наоборот: половина разделов существует, чтобы показать, что `is` даёт
True по причинам, к написанному коду отношения не имеющим, и меняются эти
причины между версиями и между способами запуска.
"""

import sys


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


def observe_small_ints() -> None:
    """Диапазон предсозданных чисел — единственная часть, на которую можно ссылаться."""
    header("1. Кеш малых чисел")

    def built_at_runtime(value: int) -> bool:
        """Число строится из строки: компилятор посчитать его заранее не может."""
        return int(str(value)) is int(str(value))

    low = None
    high = None
    for value in range(-1000, 1500):
        if built_at_runtime(value):
            if low is None:
                low = value
            high = value
    print(f"одним объектом возвращаются числа от {low} до {high}")
    print(f"int('256') is int('256'): {int('256') is int('256')}")
    print(f"int('257') is int('257'): {int('257') is int('257')}")


def observe_constants() -> None:
    """Почему `1000 is 1000` в исходнике даёт True — и почему это ничего не значит."""
    header("2. Одинаковые литералы в одном файле")

    def first() -> int:
        return 1000

    def second() -> int:
        return 1000

    print("две РАЗНЫЕ функции одного файла, литерал 1000:", first() is second())
    print("то же с длинной строкой:                      ",
          (lambda: "hello world")() is (lambda: "hello world")())

    # Отдельная компиляция — то же, что отдельный файл: свой пул констант.
    other: dict = {}
    exec(compile("value = 1000\ntext = 'hello world'\n", "<другой файл>", "exec"), other)
    print("тот же литерал из ДРУГОЙ компиляции:          ", other["value"] is first())
    print("та же строка из ДРУГОЙ компиляции:            ",
          other["text"] is (lambda: "hello world")())
    print()
    print("Компилятор объединяет равные константы в пределах одной компиляции —")
    print("даже если они лежат в разных функциях. Из другого файла тот же")
    print("литерал даёт другой объект. То есть True в первых двух строках —")
    print("свойство сборки исходника, а не свойство чисел и строк.")


def observe_interning() -> None:
    """Строки: что интернируется само, а что нет."""
    header("3. Интернирование строк")

    # Литералы вынесены в переменные намеренно: `x is "литерал"` даёт
    # SyntaxWarning с 3.8, и предупреждение это правильное — сравнивать с
    # литералом через is не следует нигде, включая замеры.
    ident = "hello_world"
    spaced = "hello world"

    runtime = "".join(["hello", "_", "world"])
    print("строка вида идентификатора, собранная в рантайме:")
    print("  собранная is литерал:      ", runtime is ident)
    print("  sys.intern(собранная) is литерал:", sys.intern(runtime) is ident)

    with_space = "".join(["hello", " ", "world"])
    print("строка с пробелом, собранная в рантайме:")
    print("  собранная is литерал:      ", with_space is spaced)

    # Литерал вида идентификатора — один объект на всю программу, включая
    # ДРУГИЕ компиляции. Проверяется тем же приёмом, что и объединение
    # констант в разделе 2: exec отдельного исходника — это отдельный пул
    # констант, и совпадение объектов там может дать только интернирование.
    other: dict = {}
    exec(compile("ident = 'hello_world'\nspaced = 'hello world'\n", "<другой файл>", "exec"), other)
    print("из ДРУГОЙ компиляции:")
    print("  литерал вида идентификатора — тот же объект:", other["ident"] is ident)
    print("  литерал с пробелом — тот же объект:        ", other["spaced"] is spaced)

    print()
    print("Правило: сам собой интернируется литерал, похожий на идентификатор.")
    print("Собранная во время выполнения строка не интернируется никогда —")
    print("даже если по виду она идентификатор. Это делает sys.intern.")


def observe_singletons() -> None:
    """Что действительно один объект на всю программу."""
    header("4. Настоящие одиночки")

    empty_str = ""
    rows = [
        ("None", None is None),
        ("True", True is bool(1)),
        ("пустой кортеж", tuple() is tuple()),
        ("пустая строка", empty_str is "".join([])),
        ("пустой frozenset", frozenset() is frozenset()),
        ("пустой список", list() is list()),
    ]
    for name, same in rows:
        print(f"{name:<20} {same}")
    print()
    print("Опираться в коде можно на None, True и False — они гарантированы")
    print("справочником языка. Остальное — детали реализации CPython.")


def observe_nan() -> None:
    """Единственное значение, для которого == и is расходятся В ОБЕ стороны."""
    header("5. nan")

    nan = float("nan")
    print("nan == nan:", nan == nan)
    print("nan is nan:", nan is nan)
    print("nan in [nan]:", nan in [nan])
    print("[nan] == [nan]:", [nan] == [nan])
    print("другой nan в множестве:", float("nan") in {nan})
    print()
    print("Контейнеры сравнивают элементы через PyObject_RichCompareBool, а он")
    print("сначала проверяет тождество и только потом равенство. Поэтому nan,")
    print("не равный сам себе, всё-таки НАХОДИТСЯ в списке — по is, не по ==.")


def observe_eq_override() -> None:
    """Почему `is None`, а не `== None`."""
    header("6. == можно переопределить, is — нельзя")

    class AlwaysEqual:
        def __eq__(self, other: object) -> bool:
            return True

        __hash__ = None  # type: ignore[assignment]

    obj = AlwaysEqual()
    nothing = None
    print("obj == None:", obj == nothing)
    print("obj is None:", obj is None)

    class WeirdEqual:
        def __eq__(self, other: object):
            return "не булево значение"

    print("bool(WeirdEqual() == 1):", bool(WeirdEqual() == 1))
    print()
    print("__eq__ может вернуть что угодно, и `if a == b` приведёт это к bool.")
    print("`is` — сравнение адресов, перехватить его нечем.")


def observe_id_reuse() -> None:
    """id уникален только среди ОДНОВРЕМЕННО живущих объектов."""
    header("7. id переиспользуется")

    print("id([]) == id([]):", id([]) == id([]))
    print()
    print("Первый список умирает до того, как создаётся второй, и адрес")
    print("достаётся второму. Сравнение id объектов, не живущих одновременно,")
    print("не значит ничего — а выглядит как сравнение объектов.")


def observe_refcounts() -> None:
    """Числа, в которые нельзя вчитываться."""
    header("8. Счётчики ссылок вечных объектов")

    print(f"sys.getrefcount(None) = {sys.getrefcount(None)}")
    print(f"sys.getrefcount(1)    = {sys.getrefcount(1)}")
    print()
    print("С 3.12 (PEP 683) None, True, False и малые числа не считают ссылок")
    print("вовсе, и getrefcount возвращает служебную константу. Её ЗНАЧЕНИЕ")
    print("между версиями разное — сравните вывод на 3.12, 3.13 и 3.14.")


def main() -> None:
    print(f"Python {sys.version.split()[0]}")
    observe_small_ints()
    observe_constants()
    observe_interning()
    observe_singletons()
    observe_nan()
    observe_eq_override()
    observe_id_reuse()
    observe_refcounts()


if __name__ == "__main__":
    main()