"""Интернирование: почему `is` для строк иногда «работает» и почему на это нельзя опираться.

ЗАЧЕМ ЭТОТ СКРИПТ. `a is b` для двух равных строк иногда True, иногда False, и
разница не случайна: CPython держит таблицу строк, в которой каждое значение
существует в одном экземпляре, и кладёт туда часть строк сам. Какую часть —
нигде не обещано и от версии к версии менялось. Отсюда единственный практический
вывод, который скрипт и предъявляет: поведение воспроизводимое, но не
гарантированное, и сравнивать строки через `is` нельзя даже там, где это
сегодня срабатывает.

КАК ЗДЕСЬ ОПРЕДЕЛЯЕТСЯ, ИНТЕРНИРОВАНА ЛИ СТРОКА. Тоже двумя способами:

1. `sys._is_interned(s)` — появилась в 3.13, приватная, но это ОФИЦИАЛЬНЫЙ
   ответ интерпретатора.
2. Два младших бита поля `state` в заголовке объекта — они же дают и ЧЕТЫРЕ
   состояния, а не два: 0 — не интернирована, 1 — интернирована, 2 —
   интернирована и бессмертна, 3 — статическая. Значения перечислены в
   `InternalDocs/string_interning.md`.

Там, где есть оба, печатаются оба. На 3.12 `sys._is_interned` нет, и остаётся
только поле — об этом скрипт говорит прямо, а не молчит.

ГДЕ ГРАНИЦА «ОДНОГО СИМВОЛА». Блок 6 отдельно проверяет ходовое «любой
одиночный символ существует в одном экземпляре»: статические одиночные строки
заведены только на однобайтовые символы, U+0000…U+00FF, и граница видна ровно
между U+00FF и U+0100. Проверка строит символы во время работы через `chr(n)` и
`join`, иначе ответ подменили бы литерал и свёртка константы. `sys._is_immortal`
там печатается только начиная с 3.14 — в 3.13 этой функции ещё нет, и состояния
«интернирована» и «бессмертна» приходится разделять по полю `state`.

ЧТО ЗДЕСЬ НЕ МЕРЯЕТСЯ. Время. Цену, которую интернирование окупает — поиск в
словаре по тому же объекту против равного, — меряет `concat.py` внутри одного
запуска.

ЗАПУСК:

    for v in 3.12 3.13 3.14; do python$v bench/strings/interning.py; done
"""

import ctypes
import platform
import sys

STATE_OFFSET = 32
NAMES = {0: "не интернирована", 1: "интернирована", 2: "бессмертная", 3: "статическая"}


def interned_bits(s: str) -> int:
    return ctypes.c_uint32.from_address(id(s) + STATE_OFFSET).value & 0b11


def official(s: str) -> str:
    fn = getattr(sys, "_is_interned", None)
    return "—" if fn is None else ("да" if fn(s) else "нет")


def head(n: int, title: str) -> None:
    line = f"{n}. {title}"
    print(f"\n{line}\n{'-' * len(line)}")


def main() -> None:
    print(f"Python {platform.python_version()}")
    print(f"Сборка: {sys.version.split('[')[-1].rstrip('] ')}")
    has_official = hasattr(sys, "_is_interned")
    print(f"\nsys._is_interned: {'есть' if has_official else 'НЕТ в этой версии, остаётся только поле state'}")

    head(1, "ЧЕТЫРЕ СОСТОЯНИЯ, А НЕ ДВА")
    print("  Младшие два бита поля state, по InternalDocs/string_interning.md:")
    for code, name in NAMES.items():
        print(f"    {code} — {name}")

    head(2, "ЧТО ИНТЕРНИРУЕТСЯ САМО")
    literal_id = "some_attribute_name"
    literal_not_id = "some attribute name!"
    at_runtime = "".join(["some_attribute", "_name"])
    number_like = "12345"
    empty = ""
    single = "q"
    long_id = "a" * 4096
    cases = [
        ("литерал, похожий на имя", literal_id),
        ("литерал с пробелами и знаком", literal_not_id),
        ("литерал из цифр", number_like),
        ("пустая строка", empty),
        ("один символ из Latin-1", single),
        ("литерал в 4096 символов", long_id),
        ("собрана join во время работы", at_runtime),
    ]
    print("  строка                          состояние поля   sys._is_interned")
    for name, s in cases:
        code = interned_bits(s)
        print(f"  {name:<30s} {code} {NAMES[code]:<16s} {official(s):>6s}")
    print("\n  Равенство и тождественность — разные вещи, и вот где они расходятся:")
    print(f"    'some_attribute_name' == собранная join:  {literal_id == at_runtime}")
    print(f"    'some_attribute_name' is собранная join:  {literal_id is at_runtime}")

    head(3, "ТОТ ЖЕ ВОПРОС, ЗАДАННЫЙ ЧЕТЫРЬМЯ СПОСОБАМИ")
    print("  Все четыре строки равны. Тождественны — не все.")
    a = "hello_world_test"
    b = "hello_" "world_test"          # склейка литералов — работа компилятора
    c = "hello_" + "world_test"        # сложение констант — свёртка при компиляции
    parts = ["hello_", "world_test"]
    d = "".join(parts)                 # сборка во время работы
    e = sys.intern("".join(parts))     # то же, но с явным интернированием
    for name, s in (("литерал", a), ('соседние литералы "x" "y"', b),
                    ('сложение литералов "x" + "y"', c),
                    ("join во время работы", d), ("sys.intern(join)", e)):
        print(f"  {name:<28s} == a: {s == a!s:<5s} is a: {s is a!s:<5s} "
              f"состояние {interned_bits(s)} {NAMES[interned_bits(s)]}")
    print("\n  Третья строка — не интернирование, а свёртка констант: компилятор")
    print("  сложил два литерала в один ещё до запуска, и дальше это просто литерал.")

    head(4, "ГДЕ ЭТО ЛОМАЕТСЯ НЕЗАМЕТНО")
    print("  Одна и та же по смыслу строка, полученная двумя путями:")
    from_source = "user_id"
    from_data = "user_id".encode().decode()
    print(f"    из исходника:      состояние {interned_bits(from_source)}")
    print(f"    из декодирования:  состояние {interned_bits(from_data)}")
    print(f"    равны:       {from_source == from_data}")
    print(f"    тождественны: {from_source is from_data}")
    print("\n  Код, который сравнивает через is, на литералах пройдёт все тесты")
    print("  и сломается на первой строке, пришедшей из файла или из сети.")

    head(5, "БЕССМЕРТНЫЕ И СТАТИЧЕСКИЕ")
    print("  Состояния 2 и 3 — это строки, которые интерпретатор не освобождает")
    print("  никогда: имена, которыми пользуется он сам.")
    samples = ["__init__", "self", "utf-8", "a", "", "3"]
    print("  строка        состояние  счётчик ссылок")
    for s in samples:
        code = interned_bits(s)
        rc = sys.getrefcount(s)
        shown = f"{rc}" if rc < 2**30 else "бессмертна (счётчик не растёт)"
        print(f"  {s!r:<13s} {code} {NAMES[code]:<16s} {shown}")
    print("\n  'utf-8' стоит здесь для контраста: дефис не даёт ей стать именем,")
    print("  и строка, которую интерпретатор использует постоянно, живёт")
    print("  на обычном счётчике ссылок.")

    head(6, "«ОДИН СИМВОЛ» — ЭТО НЕ ЛЮБОЙ СИМВОЛ")
    print("  Статические одиночные строки заведены не на все символы, а только")
    print("  на однобайтовые: U+0000…U+00FF. Проверяется это построением во время")
    print("  работы — chr(n) и join, — чтобы ни литерал, ни свёртка константы не")
    print("  подменили ответ.")
    print("  символ          chr is chr  join is chr  состояние  _is_interned  _is_immortal")
    # Греческая α стоит рядом с кириллической Ж не для полноты: английская
    # страница статьи не имеет права нести кириллицу в отображаемом тексте, и
    # без греческого примера ей нечего было бы показать в этой строке.
    boundary = [0x61, 0xE9, 0xFF, 0x100, 0x3B1, 0x416, 0x1F600]
    immortal_fn = getattr(sys, "_is_immortal", None)
    for cp in boundary:
        a = chr(cp)
        b = chr(cp)
        joined = "".join([chr(cp)])
        imm = "—" if immortal_fn is None else ("да" if immortal_fn(a) else "нет")
        print(f"  U+{cp:04X} {a!r:>7s} {a is b!s:>11s} {joined is a!s:>12s} "
              f"{interned_bits(a):>10d} {official(a):>13s} {imm:>13s}")
    print("\n  Граница ровно между U+00FF и U+0100. Ниже неё два независимо")
    print("  построенных символа — один и тот же объект; выше — разные, и")
    print("  сравнивать их через is нельзя даже для одного символа.")
    if immortal_fn is None:
        print("  sys._is_immortal в этой версии нет — столбец пуст.")


main()