"""Почему одна и та же по длине строка занимает разное место.

ЗАЧЕМ ЭТОТ СКРИПТ. У строки размер объекта при ОДИНАКОВОЙ длине задаётся самым
старшим кодом символа — систематически, без истории объекта и без запаса.
Единственным типом с переменным размером она при этом не является: у целого
размер зависит от величины числа, у списка при равной длине — от того, как его
построили. Контрпримеры печатает блок 6, чтобы это не приходилось брать на слово.

Причина самого механизма — PEP 393: CPython хранит строку не в одной кодировке, а
в той из трёх ширин, которой хватает самому старшему символу, и переключается на
следующую, как только такой символ появился. Одна буква «ё» посреди латиницы
удваивает буфер символов, один эмодзи — учетверяет; размер объекта целиком растёт
чуть иначе, потому что в него входит ещё заголовок.

КАК ЗДЕСЬ ОПРЕДЕЛЯЕТСЯ ШИРИНА. Двумя независимыми способами, и оба печатаются
рядом:

1. ИЗМЕРЕНИЕМ. `sys.getsizeof(ch * (n + 1)) - sys.getsizeof(ch * n)` — это
   ровно байт на символ, и никакого знания о внутренностях не требует.
2. ЧТЕНИЕМ ПОЛЯ. Бит-поле `state` в `PyASCIIObject`, прочитанное по адресу
   объекта. Способ зависит от раскладки структуры и от сборки.

Второй способ без первого опасен: смещение поля — предположение, и ошибиться в
нём легко, а неверное число выглядит как верное. Поэтому скрипт печатает оба и
отдельной строкой говорит, совпали они или нет. Если не совпали — верить надо
измерению, а `ctypes`-чтение считать сломанным.

ЧТО ЗДЕСЬ НЕ МЕРЯЕТСЯ. Время. Байты — раскладка объекта, их между версиями
сравнивать можно; время между версиями не сравнивается вовсе (bench/README.md),
и его меряет `concat.py` отдельно.

ЗАПУСК:

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

import ctypes
import platform
import struct
import sys

# PyASCIIObject: ob_refcnt(8) ob_type(8) length(8) hash(8) state(4).
STATE_OFFSET = 32


def state_bits(s: str) -> dict:
    raw = ctypes.c_uint32.from_address(id(s) + STATE_OFFSET).value
    return {
        "interned": raw & 0b11,
        "kind": (raw >> 2) & 0b111,
        "compact": (raw >> 5) & 1,
        "ascii": (raw >> 6) & 1,
    }


def bytes_per_char(ch: str) -> int:
    """Байт на символ — измерением, без всякого знания о структуре."""
    return sys.getsizeof(ch * 11) - sys.getsizeof(ch * 10)


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


SAMPLES = [
    ("ASCII", "a", "латиница, цифры, знаки — U+0000…U+007F"),
    ("Latin-1", "é", "буквы с надстрочными знаками, U+0080…U+00FF"),
    ("UCS-2", "ж", "кириллица, греческий, иврит — до U+FFFF"),
    ("UCS-4", "😀", "эмодзи и всё остальное выше U+FFFF"),
]


def main() -> None:
    print(f"Python {platform.python_version()}")
    print(f"Сборка: {sys.version.split('[')[-1].rstrip('] ')}")
    print(f"Указатель: {struct.calcsize('P')} Б — числа заголовков ниже относятся к этой разрядности")
    print("\nЗдесь меряются байты — раскладка объекта, а не время.")
    print("Числа этого файла сравнимы между версиями; время — нет и не меряется.")

    head(1, "ОДНА БУКВА МЕНЯЕТ РАЗМЕР ВСЕЙ СТРОКИ")
    base = "x" * 20
    variants = [
        ("двадцать латинских букв", base),
        ("те же двадцать, одна заменена на é", "é" + base[1:]),
        ("те же двадцать, одна заменена на ж", "ж" + base[1:]),
        ("те же двадцать, одна заменена на α", "α" + base[1:]),
        ("те же двадцать, одна заменена на 😀", "😀" + base[1:]),
    ]
    print("  строка                                длина  getsizeof")
    first = sys.getsizeof(base)
    for name, s in variants:
        size = sys.getsizeof(s)
        mult = f"×{size / first:.2f}" if s is not base else "—"
        print(f"  {name:<36s} {len(s):>5d} {size:>9d} Б  {mult}")
    print("\n  Длина одна и та же во всех строках. Меняется содержимое, и вместе")
    print("  с ним — ширина, которой CPython хранит КАЖДЫЙ символ.")
    print("  Кириллическая ж и греческая α дают одно и то же: обе лежат в одном")
    print("  диапазоне, и выбор ширины зависит только от него, а не от алфавита.")

    head(2, "ЧЕТЫРЕ ПРЕДСТАВЛЕНИЯ: БАЙТ НА СИМВОЛ И ЗАГОЛОВОК")
    print("  представление  байт/символ  заголовок   что помещается в эту ширину")
    agree = True
    rows = []
    for name, ch, what in SAMPLES:
        per = bytes_per_char(ch)
        # Заголовок — то, что останется, если вычесть символы и завершающий ноль.
        header = sys.getsizeof(ch * 10) - 10 * per - per
        bits = state_bits(ch)
        expected_kind = {1: 1, 2: 2, 4: 4}[per]
        if bits["kind"] != expected_kind:
            agree = False
        rows.append((name, per, header, bits, what))
        print(f"  {name:<14s} {per:>11d} {header:>10d}   {what}")
    ten_ascii = sys.getsizeof("x" * 10)
    ten_latin = sys.getsizeof("é" * 10)
    print(f"\n  getsizeof('')        = {sys.getsizeof(''):>4d} Б — один заголовок ASCII и ноль")
    print(f"  getsizeof('x' * 10)  = {ten_ascii:>4d} Б — заголовок 40, десять байт, ноль")
    print(f"  getsizeof('é' * 10)  = {ten_latin:>4d} Б — байт на символ тот же, заголовок 56")
    print(f"  разница заголовков   = {ten_latin - ten_ascii:>4d} Б — поля под кешированное")
    print("                              представление в UTF-8, которых у ASCII нет")
    print(f"\n  А вот одиночная 'é' даёт {sys.getsizeof('é')} Б, а не 58: это статическая")
    print("  строка, у которой представление в UTF-8 уже посчитано и лежит рядом.")
    print("  Мерить заголовок по строке в один символ поэтому нельзя.")

    head(3, "ПОЛЕ state, ПРОЧИТАННОЕ ИЗ ОБЪЕКТА")
    print("  Второй, независимый способ узнать ширину: бит-поле в заголовке.")
    print("  представление  kind  compact  ascii   kind, ожидаемый по замеру")
    for name, per, _header, bits, _what in rows:
        print(f"  {name:<14s} {bits['kind']:>4d} {bits['compact']:>8d} {bits['ascii']:>6d}"
              f"   { ({1: 1, 2: 2, 4: 4}[per]) :>22d}")
    print(f"\n  измерение и чтение поля совпали: {'да' if agree else 'НЕТ — верить измерению'}")

    head(4, "НЕКОМПАКТНАЯ ФОРМА: ПОДКЛАСС str")
    class MyStr(str):
        pass

    plain = "abc"
    sub = MyStr("abc")
    print(f"  'abc'            getsizeof={sys.getsizeof(plain):>4d} Б  compact={state_bits(plain)['compact']}")
    print(f"  MyStr('abc')     getsizeof={sys.getsizeof(sub):>4d} Б  compact={state_bits(sub)['compact']}")
    print("\n  У компактной формы символы лежат сразу за заголовком: один объект,")
    print("  одно выделение памяти, и getsizeof считает всё. У подкласса compact=0 —")
    print("  заголовок шире, а символы лежат отдельным выделением, которого в этом")
    print(f"  числе уже нет. То есть {sys.getsizeof(sub)} Б — это нижняя оценка, а не размер.")

    head(5, "ЧТО ИЗ ЭТОГО СЛЕДУЕТ ДЛЯ МИЛЛИОНА КОРОТКИХ СТРОК")
    n = 1_000_000
    print(f"  {n} строк по 16 символов, только сами строки, без контейнера:")
    for name, ch, _what in SAMPLES:
        one = sys.getsizeof(ch * 16)
        print(f"  {name:<14s} {one:>4d} Б на строку → {one * n / 1024 ** 2:>8.1f} МиБ")
    print("\n  Разница между первой и последней строкой — это одна и та же")
    print("  информация, записанная четырьмя разными ширинами.")

    head(6, "СТРОКА — НЕ ЕДИНСТВЕННЫЙ ТАКОЙ ТИП")
    print("  Ходовое «str — единственный встроенный тип, размер которого зависит")
    print("  от содержимого» неверно: у целого он зависит от величины, а у")
    print("  контейнеров — от истории. Вот контрпримеры, один запуск:")
    print("  выражение                            len  getsizeof")
    same_len_ints = [("0", 0), ("2**30", 2**30), ("2**100", 2**100), ("2**1000", 2**1000)]
    for expr, value in same_len_ints:
        print(f"  int {expr:<32s}   — {sys.getsizeof(value):>9d} Б")
    # Контрпример со списком нарочно взят такой, который не зависит от версии:
    # два способа построить список одной длины. Способ через del даёт на 3.12
    # другое число — он опирается на поведение, которое менялось, — и тащить
    # это расхождение в файл про раскладку СТРОКИ незачем.
    by_append: list[int] = []
    for i in range(100):
        by_append.append(i)
    exact = list(range(100))
    print(f"  list(range(100))                     {len(exact):>3d} {sys.getsizeof(exact):>10d} Б")
    print(f"  тот же по длине, собран append       {len(by_append):>3d} {sys.getsizeof(by_append):>10d} Б")
    print("\n  Так что точная формулировка другая: у str размер при ОДИНАКОВОЙ")
    print("  длине определяется максимальным кодом символа — систематически и")
    print("  без всякой истории объекта. У int он зависит от величины числа, а не")
    print("  от длины записи; у списка при равной длине — от того, как его")
    print("  строили: тот же список, собранный append, несёт запас.")


main()