"""Что `is` обещает языком и чем это оказывается в CPython.

ЗАЧЕМ ЭТОТ ФАЙЛ. В уроке `is` определялся как «сравнение адресов». Аудит
возразил: контракт другой — `x is y` истинно тогда и только тогда, когда `x` и
`y` один и тот же объект. Адрес тут ни при чём: он появляется только потому,
что ИМЕННО ТАК тождество реализовано в CPython, а `id()` документирован как
уникальное и постоянное В ТЕЧЕНИЕ ЖИЗНИ объекта число, а не как место в памяти.

Разница не философская, и блок 2 показывает почему: число, возвращённое `id()`,
переиспользуется. Объект уничтожен — и следующий может получить тот же `id`.
Если бы `id` был «адресом объекта» в том смысле, в каком его понимает читатель
(постоянный признак вещи), такого быть не могло бы.

ЧТО ЗДЕСЬ ЕСТЬ. Блоки 1 и 2 — про контракт и про его реализацию. Блоки 3–6 —
про то, где `is` уместен (одиночки и часовые) и где он обманывает (кеш малых
целых, интернирование, NaN в контейнерах). Всё печатается прогоном: числа и
ответы не назначены руками.

ЗАПУСК: python3.13 bench/identity/contract.py
Вывод по версиям: runs/contract-3.11.txt и соседние.
"""

import enum
import gc
import sys


def show(title: str) -> None:
    print()
    print(title)
    print("-" * len(title))


def row(label: str, value: object) -> None:
    print(f"  {label:<46} {value}")


# ------------------------------------------------------------------ 1
def block1() -> None:
    show("1. Контракт: тот же объект или нет")
    a = ["x"]
    b = ["x"]
    c = a
    row("a == b (равны по значению)", a == b)
    row("a is b (один ли это объект)", a is b)
    row("a is c (c — то же имя того же объекта)", a is c)
    a.append("y")
    row("после a.append('y'): c", c)
    row("то есть c и a", "один объект, а не копия")


# ------------------------------------------------------------------ 2
def block2() -> None:
    show("2. id уникален в течение ЖИЗНИ объекта, а не навсегда")

    class Thing:
        __slots__ = ("value",)

        def __init__(self, value):
            self.value = value

    first = Thing(1)
    first_id = id(first)
    del first
    gc.collect()

    # Ищем переиспользование: создаём объекты того же типа и смотрим, не
    # достанется ли кому-нибудь то же число. Цикл ограничен — если не
    # повторилось, так и печатаем: утверждение «id переиспользуется» проверяемо
    # и не должно превращаться в «обычно бывает».
    reused_at = None
    keep = []
    for i in range(1000):
        candidate = Thing(2)
        if id(candidate) == first_id:
            reused_at = i
            break
        keep.append(candidate)

    row("id первого объекта", first_id)
    row("тот же id достался другому объекту", "нет" if reused_at is None else f"да, попытка {reused_at}")
    row("вывод", "id уникален среди ОДНОВРЕМЕННО живущих объектов")


# ------------------------------------------------------------------ 3
def block3() -> None:
    show("3. Где `is` уместен: одиночки и часовые")

    class Color(enum.Enum):
        RED = 1
        BLUE = 2

    MISSING = object()

    def find(mapping, key, default=MISSING):
        got = mapping.get(key, MISSING)
        return "ключа нет" if got is MISSING else got

    row("None is None", None is None)
    row("NotImplemented is NotImplemented", NotImplemented is NotImplemented)
    row("Ellipsis is ...", Ellipsis is ...)
    row("Color.RED is Color(1)", Color.RED is Color(1))
    row("часовой различает отсутствие и None", find({"k": None}, "k"))
    row("и настоящее отсутствие", find({}, "k"))
    row("почему не == None", "== зовёт __eq__ чужого объекта; is не зовёт ничего")


# ------------------------------------------------------------------ 4
def block4() -> None:
    show("4. Кеш малых целых: деталь реализации, а не правило")
    a, b = 256, 256
    c, d = 257, 257  # оба из одной строки: их складывает компилятор
    e = int("257")
    f = int("257")
    row("256 is 256 (из констант)", a is b)
    row("257 is 257 (из констант одной строки)", c is d)
    row("int('257') is int('257')", e is f)
    row("границы кеша в этой сборке", f"[{-5}, {256}]")


# ------------------------------------------------------------------ 5
def block5() -> None:
    show("5. Интернирование строк: тоже про сборку, а не про язык")
    x = "deep"
    y = "deep"
    built = "de" + "ep"          # сложит компилятор
    runtime = "".join(["d", "e", "e", "p"])
    row("два одинаковых литерала", x is y)
    row("литерал и склейка констант", x is built)
    row("литерал и строка, собранная в рантайме", x is runtime)
    row("после sys.intern", x is sys.intern("".join(["d", "e", "e", "p"])))
    weird = "не идентификатор!"
    weird2 = "не идентификатор!"
    row("строка с пробелами и знаками", weird is weird2)


# ------------------------------------------------------------------ 6
def block6() -> None:
    show("6. NaN: где тождество опережает равенство")
    nan = float("nan")
    row("nan == nan", nan == nan)
    row("nan is nan", nan is nan)
    row("[nan] == [nan] (один и тот же объект)", [nan] == [nan])
    row("nan in [nan]", nan in [nan])
    row("[float('nan')] == [float('nan')]", [float("nan")] == [float("nan")])
    row("почему", "контейнер сначала спрашивает про тождество, потом про равенство")


def main() -> None:
    print(f"Python {sys.version.split()[0]} ({sys.implementation.name})")
    block1()
    block2()
    block3()
    block4()
    block5()
    block6()


if __name__ == "__main__":
    main()