"""Почему объект жив, хотя ссылок на него «нет»: циклы и скрытые ссылки.

Времени здесь нет — только то, жив ли объект в данный момент. Живость
проверяется слабой ссылкой: она объект не держит, а после его смерти
возвращает None. Так проверка не мешает тому, что проверяет.

ШЕСТЬ СЮЖЕТОВ:

1. БЕЗ ЦИКЛА. `del` последней ссылки — и объект умирает сразу, на этой же
   строке. Сборщик циклов здесь не участвует.

2. ЦИКЛ. Две вершины ссылаются друг на друга; `del` обоих имён — и обе
   живы. Умирают только на `gc.collect()`, и он же возвращает число
   найденных недостижимых объектов.

3. ИСКЛЮЧЕНИЕ. `except ... as e` чистит имя в конце блока — и справочник
   объясняет почему: трассировка держит кадр, кадр держит локальные
   переменные, и исключение в локальной переменной замыкает цикл. Здесь
   проверены оба случая: исключение в локальной переменной (после выхода из
   функции группа недостижима — объект ждёт сборщика) и в атрибуте живого
   объекта (всё достижимо от живого держателя — сборщик объект не тронет, а
   убранная ссылка освобождает его сразу).

4. LRU_CACHE НА МЕТОДЕ. Кеш держит `self` в ключе, пока запись не вытеснена
   или кеш не очищен.

5. СВЯЗАННЫЙ МЕТОД В РЕЕСТРЕ. Подписка `callbacks.append(obj.on_event)` —
   это ссылка на `obj`. `weakref.WeakMethod` её не держит.

6. __del__ В ЦИКЛЕ. До 3.4 такой цикл сборщик не трогал и складывал в
   `gc.garbage`; после PEP 442 он собирается, а `gc.garbage` пуст.

Запускать: python3.11 / 3.12 / 3.13 / 3.14.
"""
import functools
import gc
import sys
import weakref

print("PY", sys.version.split()[0], "| пороги", gc.get_threshold())
print()


def alive(ref):
    return "жив" if ref() is not None else "мёртв"


class Node:
    def __init__(self, name):
        self.name = name
        self.other = None


# Сборщик выключен на время опытов 1–5: иначе он может сработать сам посреди
# сюжета, и «жив до gc.collect()» превратится в «жив, пока повезёт». Включён
# он обратно перед шестым опытом и в конце.
gc.collect()
gc.disable()

# --- 1. Без цикла ------------------------------------------------------------------
print("1) без цикла")
a = Node("a")
r = weakref.ref(a)
print("   до del:", alive(r))
del a
print("   сразу после del:", alive(r), "— освобождён счётчиком ссылок, сборщик не нужен")
print()

# --- 2. Цикл -----------------------------------------------------------------------
print("2) цикл из двух вершин")
a, b = Node("a"), Node("b")
a.other, b.other = b, a
ra, rb = weakref.ref(a), weakref.ref(b)
print("   sys.getrefcount(a) до del:", sys.getrefcount(a))
del a, b
print("   после del a, b:", alive(ra), "и", alive(rb))
found = gc.collect()
print(f"   gc.collect() вернул {found}; теперь:", alive(ra), "и", alive(rb))
print()

# --- 3. Исключение ---------------------------------------------------------------------
print("3) исключение и кадр упавшей функции")


class Payload:
    """Крупный объект, живущий в локальной переменной упавшей функции."""


def work(sink, keep=None, local=False):
    payload = Payload()
    sink.append(weakref.ref(payload))
    try:
        raise ValueError("сбой")
    except ValueError as e:
        if keep is not None:
            keep.last_error = e
        if local:
            err = e  # noqa: F841 — та самая локальная ссылка из справочника


class Service:
    last_error = None


refs = []
work(refs)
print("   исключение нигде не сохранено: payload после выхода из функции —", alive(refs[-1]))

work(refs, local=True)
print("   сохранено в локальную err: payload после выхода —", alive(refs[-1]))
print("     цикл: кадр -> err -> исключение -> __traceback__ -> кадр")
gc.collect()
print("     после gc.collect():", alive(refs[-1]))

svc = Service()
work(refs, keep=svc)
print("   сохранено в svc.last_error: payload после выхода —", alive(refs[-1]))
print("     путь от живого svc: svc -> исключение -> __traceback__ -> кадр -> payload")
gc.collect()
print("     gc.collect() при живом svc:", alive(refs[-1]))
svc.last_error = None
print("     svc.last_error = None:", alive(refs[-1]))

try:
    raise ValueError("сбой")
except ValueError as e:
    pass
try:
    e  # noqa: B018
    print("   имя e после блока except: существует")
except NameError:
    print("   имя e после блока except: NameError — его удалил сам интерпретатор")
print()

# --- 4. lru_cache на методе -------------------------------------------------------------
print("4) functools.lru_cache на методе")


class Report:
    @functools.lru_cache(maxsize=128)
    def total(self, n):
        return n * 2


rep = Report()
rep.total(10)
rr = weakref.ref(rep)
del rep
print("   del rep:", alive(rr), "— self лежит в ключе кеша")
gc.collect()
print("   gc.collect():", alive(rr))
Report.total.cache_clear()
print("   Report.total.cache_clear():", alive(rr))
print()

# --- 5. Связанный метод в реестре --------------------------------------------------------
print("5) связанный метод в списке подписчиков")


class Widget:
    def on_event(self):
        return "ok"


callbacks = []
w = Widget()
callbacks.append(w.on_event)
rw = weakref.ref(w)
del w
print("   callbacks.append(w.on_event); del w:", alive(rw), "— метод держит __self__")
gc.collect()
print("   gc.collect():", alive(rw))
callbacks.clear()
print("   callbacks.clear():", alive(rw))

weak_callbacks = []
w = Widget()
weak_callbacks.append(weakref.WeakMethod(w.on_event))
rw = weakref.ref(w)
del w
print("   то же через weakref.WeakMethod; del w:", alive(rw))
print("   weak_callbacks[0]() ->", weak_callbacks[0]())
print()

# --- 6. __del__ в цикле ------------------------------------------------------------------
print("6) __del__ у обеих вершин цикла")
gc.enable()
order = []


class Finalized(Node):
    def __del__(self):
        order.append(self.name)


a, b = Finalized("a"), Finalized("b")
a.other, b.other = b, a
del a, b
found = gc.collect()
print(f"   gc.collect() вернул {found}; финализаторы выполнились: {order}")
print(f"   gc.garbage: {gc.garbage}")