11.4-dars: Reference counting

oxirgi_xatolar = []

def sorovni_ishla(sorov):
    hisobot = Hisobot.yarat(sorov)          # 50 MB
    try:
        hisobot.hisobla()
    except HisobXatosi as e:
        oxirgi_xatolar.append(e)            # "keyin ko'rib chiqamiz"
        raise

class Fayl:
    def __del__(self):
        print("yopildi")

import gc
gc.get_referrers(obj)       # obj ga ishora qiluvchi konteynerlar (GC kuzatadigan)
gc.get_referents(obj)       # obj ishora qiladigan obyektlar

+1: nomga bog'lash, konteynerga qo'yish, atribut, argument, closure, bog'langan metod
−1: del, qayta bog'lash, konteynerdan olish, funksiyadan chiqish
0  → darhol: __del__ → ichkilarga DECREF → zanjir → xotira

global nom:       haqiqiy + 1
3.14 lokal nom:   ko'pincha haqiqiy (qarz)
o'lmas:           maxsus son
→ farq sifatida ishlating

saqlangan istisno → traceback → freym → lokallar
to'xtatilgan generator, closure, bog'langan metod, lru_cache, global ro'yxat, klass atributi

bir marta (PEP 442)     xato → "Exception ignored"     yopilishda kafolat yo'q
resurs uchun: with / weakref.finalize

gc.get_referrers(obj)    gc.get_referents(obj)    weakref.ref(obj)() is None

"""ob_refcnt ni aniq o'qish; har amal qancha havola qo'shadi; getrefcount ning global va lokal farqi."""

import ctypes
import sys


def refcnt(obj):
    return ctypes.c_ssize_t.from_address(id(obj)).value


class Tugun:
    def metod(self):
        return self


print("=== 1. Qaysi amal havola qo'shadi ===")
obyekt = Tugun()
qadamlar = [("yaratildi", None)]
boshlangich = refcnt(obyekt)
saqlagichlar = []


def qadam(tavsif):
    print(f"  {tavsif:34} ob_refcnt = {refcnt(obyekt)}  (+{refcnt(obyekt) - boshlangich})")


qadam("obyekt = Tugun()")
b = obyekt
qadam("b = obyekt")
royxat = [obyekt, obyekt]
qadam("royxat = [obyekt, obyekt]")
lugat = {"kalit": obyekt}
qadam("lugat['kalit'] = obyekt")
kortej = (obyekt,)
qadam("kortej = (obyekt,)")
boshqa = Tugun()
boshqa.havola = obyekt
qadam("boshqa.havola = obyekt")
bogl = obyekt.metod
qadam("bogl = obyekt.metod  (__self__)")
closure = (lambda: obyekt)
qadam("lambda: obyekt  (global — hujayra yo'q)")


def yasa(x):
    return lambda: x


closure2 = yasa(obyekt)
qadam("yasa(obyekt) — closure hujayrasi")
del b, royxat, lugat, kortej, boshqa, bogl, closure2
qadam("hammasi del qilindi")

print("\n=== 2. sys.getrefcount: global va lokal ===")
print(f"  global: ob_refcnt={refcnt(obyekt)}, sys.getrefcount={sys.getrefcount(obyekt)}")


def lokal_sinov():
    lokal = Tugun()
    return refcnt(lokal), sys.getrefcount(lokal)


print(f"  lokal 3.14-bob: ob_refcnt={lokal_sinov()[0]}, sys.getrefcount={lokal_sinov()[1]}")
print("  ⚠️ getrefcount ni farq sifatida ishlating")

print("\n=== 3. Funksiya chaqiruvi davomida ===")


def ichkarida(x):
    return refcnt(x)


oldin = refcnt(obyekt)
print(f"  chaqiruvdan oldin {oldin}, chaqiruv ichida {ichkarida(obyekt)}, keyin {refcnt(obyekt)}")
print("  (tashqarida: global nom + refcnt() argumenti; ichkarida: global nom + x parametri — ikkalasida bittadan qo'shimcha)")

print("\n=== 4. Generator freymi ushlab turadi ===")


def generator(x):
    yield x
    yield x


oldin = refcnt(obyekt)
g = generator(obyekt)
next(g)
print(f"  to'xtatilgan generator: +{refcnt(obyekt) - oldin}")
g.close()
print(f"  g.close() dan keyin:    +{refcnt(obyekt) - oldin}")

=== 1. Qaysi amal havola qo'shadi ===
  obyekt = Tugun()                   ob_refcnt = 2  (+0)
  b = obyekt                         ob_refcnt = 3  (+1)
  royxat = [obyekt, obyekt]          ob_refcnt = 5  (+3)
  lugat['kalit'] = obyekt            ob_refcnt = 6  (+4)
  kortej = (obyekt,)                 ob_refcnt = 7  (+5)
  boshqa.havola = obyekt             ob_refcnt = 8  (+6)
  bogl = obyekt.metod  (__self__)    ob_refcnt = 9  (+7)
  lambda: obyekt  (global — hujayra yo'q) ob_refcnt = 9  (+7)
  yasa(obyekt) — closure hujayrasi   ob_refcnt = 10  (+8)
  hammasi del qilindi                ob_refcnt = 2  (+0)

=== 2. sys.getrefcount: global va lokal ===
  global: ob_refcnt=2, sys.getrefcount=2
  lokal 3.14-bob: ob_refcnt=1, sys.getrefcount=1
  ⚠️ getrefcount ni farq sifatida ishlating

=== 3. Funksiya chaqiruvi davomida ===
  chaqiruvdan oldin 2, chaqiruv ichida 2, keyin 2
  (tashqarida: global nom + refcnt() argumenti; ichkarida: global nom + x parametri — ikkalasida bittadan qo'shimcha)

=== 4. Generator freymi ushlab turadi ===
  to'xtatilgan generator: +1
  g.close() dan keyin:    +0

"""del, qayta bog'lash, funksiyadan chiqish, konteynerdan olish, zanjir; __del__ dagi xato, tirilish."""

import sys


class R:
    def __init__(self, nom):
        self.nom = nom

    def __del__(self):
        print(f"    🗑 {self.nom}")


print("=== 1. Darhol o'chirish ===")
r = R("del bilan")
print("  del dan oldin")
del r
print("  del dan keyin")
r = R("birinchi")
r = R("ikkinchi")
print("  qayta bog'lashdan keyin")
del r


def funksiya():
    lokal = R("lokal o'zgaruvchi")
    print("  funksiya tugayapti")


funksiya()
print("  funksiyadan keyin")
royxat = [R("ro'yxat elementi")]
royxat.pop()
print("  pop dan keyin")

print("\n=== 2. Zanjir: tashqaridan ichkariga ===")
ota = R("ota")
ota.bola = R("bola")
ota.bola.nevara = R("nevara")
del ota

print("\n=== 3. Ikki havola — ikkinchisi yo'qolguncha tirik ===")
a = R("ikki havolali")
b = a
del a
print("  a o'chirildi, b hali ushlab turibdi")
del b

print("\n=== 4. __del__ dagi xato tashqariga chiqmaydi ===")


def hook(xabar):
    print(f"    unraisablehook: {type(xabar.exc_value).__name__}: {xabar.exc_value}")


eski_hook = sys.unraisablehook
sys.unraisablehook = hook


class XatoliDel:
    def __del__(self):
        raise RuntimeError("fayl yopilmadi")


x = XatoliDel()
del x
print("  dastur davom etdi")
sys.unraisablehook = eski_hook

print("\n=== 5. Tirilish: __del__ faqat bir marta ===")
qabriston = []


class Tiriluvchi:
    def __del__(self):
        print("    __del__ chaqirildi — o'zini saqlayapti")
        qabriston.append(self)


t = Tiriluvchi()
del t
print(f"  tirildi: {len(qabriston)} ta obyekt ro'yxatda")
qabriston.clear()
print("  ro'yxat tozalandi — __del__ ikkinchi marta chaqirilmadi")

=== 1. Darhol o'chirish ===
  del dan oldin
    🗑 del bilan
  del dan keyin
    🗑 birinchi
  qayta bog'lashdan keyin
    🗑 ikkinchi
  funksiya tugayapti
    🗑 lokal o'zgaruvchi
  funksiyadan keyin
    🗑 ro'yxat elementi
  pop dan keyin

=== 2. Zanjir: tashqaridan ichkariga ===
    🗑 ota
    🗑 bola
    🗑 nevara

=== 3. Ikki havola — ikkinchisi yo'qolguncha tirik ===
  a o'chirildi, b hali ushlab turibdi
    🗑 ikki havolali

=== 4. __del__ dagi xato tashqariga chiqmaydi ===
    unraisablehook: RuntimeError: fayl yopilmadi
  dastur davom etdi

=== 5. Tirilish: __del__ faqat bir marta ===
    __del__ chaqirildi — o'zini saqlayapti
  tirildi: 1 ta obyekt ro'yxatda
  ro'yxat tozalandi — __del__ ikkinchi marta chaqirilmadi

"""Saqlangan istisno freymni ushlaydi; generator, closure, callback, kesh; gc.get_referrers bilan topish va tuzatish."""

import gc
import traceback
import weakref
from functools import lru_cache


class Hisobot:
    def __init__(self, nom):
        self.nom = nom
        self.malumot = bytearray(1_000_000)

    def __repr__(self):
        return f"Hisobot({self.nom!r})"


def tirikmi(havola):
    return "tirik" if havola() is not None else "o'lgan"


print("=== 1. ⚠️ Saqlangan istisno lokal o'zgaruvchilarni ushlaydi ===")
xatolar = []
xato_matnlari = []


def ishla(nom, saqlash_usuli):
    hisobot = Hisobot(nom)
    havola = weakref.ref(hisobot)
    try:
        raise ValueError(f"{nom}: hisoblashda xato")
    except ValueError as e:
        if saqlash_usuli == "obyekt":
            xatolar.append(e)
        else:
            xato_matnlari.append("".join(traceback.format_exception(e)).strip().splitlines()[-1])
    return havola


h1 = ishla("A", "obyekt")
h2 = ishla("B", "matn")
print(f"  istisno obyekti saqlandi: Hisobot A — {tirikmi(h1)}")
print(f"  faqat matn saqlandi:      Hisobot B — {tirikmi(h2)}, matn: {xato_matnlari[0]!r}")


def kim_ushlab_turibdi(obj, chuqurlik=4):
    zanjir = []
    joriy = obj
    for _ in range(chuqurlik):
        egalar = [r for r in gc.get_referrers(joriy)
                  if r is not zanjir and type(r).__name__ not in ("list_iterator",)
                  and r is not globals() and not (isinstance(r, list) and r is gc.garbage)]
        egalar = [r for r in egalar if type(r).__name__ in ("frame", "dict", "traceback", "ValueError", "list")]
        if not egalar:
            break
        joriy = egalar[0]
        zanjir.append(type(joriy).__name__)
        if joriy is xatolar:
            break
    return " ← ".join(zanjir)


print(f"  Hisobot A ni kim ushlaydi: Hisobot ← {kim_ushlab_turibdi(h1())}")
xatolar[0].__traceback__ = None
gc.collect()
print(f"  e.__traceback__ = None dan keyin: Hisobot A — {tirikmi(h1)}")

print("\n=== 2. To'xtatilgan generator ===")


def hisobot_oqimi():
    hisobot = Hisobot("generator")
    yield hisobot.nom
    yield "oxiri"


g = hisobot_oqimi()
print(f"  next(g) = {next(g)!r}")
gh = weakref.ref(g.gi_frame.f_locals["hisobot"])
print(f"  to'xtatilgan: {tirikmi(gh)}")
g.close()
print(f"  g.close(): {tirikmi(gh)}")

print("\n=== 3. Callback, kesh va closure ===")


class Tugma:
    def __init__(self):
        self.ishlovchilar = []


class Oyna:
    def __init__(self, tugma):
        self.hisobot = Hisobot("oyna")
        tugma.ishlovchilar.append(self.yangila)

    def yangila(self):
        return self.hisobot.nom


tugma = Tugma()
oyna_havola = weakref.ref(Oyna(tugma))
print(f"  bog'langan metod callback'da: Oyna — {tirikmi(oyna_havola)}")
tugma.ishlovchilar.clear()
print(f"  callback olib tashlangach: Oyna — {tirikmi(oyna_havola)}")


@lru_cache(maxsize=None)
def tahlil(hisobot):
    return len(hisobot.malumot)


kesh_hisobot = Hisobot("kesh")
kh = weakref.ref(kesh_hisobot)
tahlil(kesh_hisobot)
del kesh_hisobot
print(f"  lru_cache argumenti: {tirikmi(kh)}")
tahlil.cache_clear()
print(f"  cache_clear(): {tirikmi(kh)}")


def yasa_hisoblagich(hisobot):
    return lambda: len(hisobot.malumot)


c_hisobot = Hisobot("closure")
ch = weakref.ref(c_hisobot)
hisoblagich = yasa_hisoblagich(c_hisobot)
del c_hisobot
print(f"  closure hujayrasi: {tirikmi(ch)}")
del hisoblagich
print(f"  closure o'chirilgach: {tirikmi(ch)}")

=== 1. ⚠️ Saqlangan istisno lokal o'zgaruvchilarni ushlaydi ===
  istisno obyekti saqlandi: Hisobot A — tirik
  faqat matn saqlandi:      Hisobot B — o'lgan, matn: 'ValueError: B: hisoblashda xato'
  Hisobot A ni kim ushlaydi: Hisobot ← frame ← traceback ← ValueError ← list
  e.__traceback__ = None dan keyin: Hisobot A — o'lgan

=== 2. To'xtatilgan generator ===
  next(g) = 'generator'
  to'xtatilgan: tirik
  g.close(): o'lgan

=== 3. Callback, kesh va closure ===
  bog'langan metod callback'da: Oyna — tirik
  callback olib tashlangach: Oyna — o'lgan
  lru_cache argumenti: tirik
  cache_clear(): o'lgan
  closure hujayrasi: tirik
  closure o'chirilgach: o'lgan

"""weakref.finalize bilan hayot davri jurnali; __del__ vs finalize; sizish sabablarini gc.get_referrers bilan tahlil."""

import gc
import weakref
from functools import lru_cache


class Kuzatuvchi:
    def __init__(self):
        self.tiriklar = weakref.WeakValueDictionary()
        self.yaratildi = 0
        self.oldi = 0

    def royxatga_ol(self, obj, nom):
        self.yaratildi += 1
        self.tiriklar[nom] = obj
        weakref.finalize(obj, self._oldi)

    def _oldi(self):
        self.oldi += 1

    def hisobot(self):
        return {"yaratildi": self.yaratildi, "oldi": self.oldi, "tirik": sorted(self.tiriklar.keys())}


kuzat = Kuzatuvchi()


class Sorov:
    def __init__(self, raqam):
        self.raqam = raqam
        self.tana = bytearray(100_000)
        kuzat.royxatga_ol(self, f"sorov-{raqam}")


xatolar = []
tinglovchilar = []


@lru_cache(maxsize=None)
def narx_hisobla(sorov):
    return sorov.raqam * 1000


def tinglovchi_qosh(sorov):
    tinglovchilar.append(lambda: sorov.raqam)


def ishla(raqam):
    sorov = Sorov(raqam)
    if raqam % 10 == 3:
        try:
            raise TimeoutError(f"so'rov {raqam}")
        except TimeoutError as e:
            xatolar.append(e)
    elif raqam % 10 == 7:
        tinglovchi_qosh(sorov)
    elif raqam % 10 == 9:
        narx_hisobla(sorov)
    return sorov.raqam


for i in range(30):
    ishla(i)

print("=== 1. 30 ta so'rovdan keyin ===")
h = kuzat.hisobot()
print(f"  yaratildi: {h['yaratildi']}, o'ldi: {h['oldi']}, tirik qoldi: {len(h['tirik'])}")
print(f"  tiriklar: {h['tirik']}")


def sabab(obj):
    for ega in gc.get_referrers(obj):
        tur = type(ega).__name__
        if tur == "frame":
            for ega2 in gc.get_referrers(ega):
                if type(ega2).__name__ == "traceback":
                    return "saqlangan istisno traceback'i"
        if tur == "cell":
            return "closure hujayrasi (tinglovchi lambda)"
        if tur == "tuple":
            for ega2 in gc.get_referrers(ega):
                if type(ega2).__name__ == "dict" and ega2 is not globals():
                    return "lru_cache kaliti"
    return "noma'lum"


print("\n=== 2. Sizish sabablari ===")
for nom in sorted(kuzat.tiriklar.keys(), key=lambda n: int(n.split("-")[1])):
    obj = kuzat.tiriklar.get(nom)
    if obj is not None:
        print(f"  {nom:10} ← {sabab(obj)}")
        del obj

print("\n=== 3. Tuzatishlar ===")
for e in xatolar:
    e.__traceback__ = None
print(f"  traceback'lar tozalandi → tirik: {len(kuzat.tiriklar)}")
tinglovchilar.clear()
print(f"  tinglovchilar tozalandi → tirik: {len(kuzat.tiriklar)}")
narx_hisobla.cache_clear()
gc.collect()
print(f"  kesh tozalandi → tirik: {len(kuzat.tiriklar)}, o'ldi: {kuzat.oldi}/{kuzat.yaratildi}")

print("\n=== 4. __del__ va weakref.finalize ===")


class DelBilan:
    def __del__(self):
        print("    __del__: self hali mavjud — lekin tirilish mumkin, interpretator yopilishida kafolat yo'q")


def tozalovchi(nom):
    print(f"    finalize: {nom} — self ga havola yo'q, faqat kerakli argumentlar")


d = DelBilan()
del d
f_obj = Sorov(999)
fin = weakref.finalize(f_obj, tozalovchi, "sorov-999")
print(f"  finalize tirikmi: {fin.alive}, interpretator yopilishida ham chaqiriladi (atexit): {fin.atexit}")
del f_obj
print(f"  obyekt o'lgach finalize tirikmi: {fin.alive}   (bir marta ishladi)")

=== 1. 30 ta so'rovdan keyin ===
  yaratildi: 30, o'ldi: 21, tirik qoldi: 9
  tiriklar: ['sorov-13', 'sorov-17', 'sorov-19', 'sorov-23', 'sorov-27', 'sorov-29', 'sorov-3', 'sorov-7', 'sorov-9']

=== 2. Sizish sabablari ===
  sorov-3    ← saqlangan istisno traceback'i
  sorov-7    ← closure hujayrasi (tinglovchi lambda)
  sorov-9    ← lru_cache kaliti
  sorov-13   ← saqlangan istisno traceback'i
  sorov-17   ← closure hujayrasi (tinglovchi lambda)
  sorov-19   ← lru_cache kaliti
  sorov-23   ← saqlangan istisno traceback'i
  sorov-27   ← closure hujayrasi (tinglovchi lambda)
  sorov-29   ← lru_cache kaliti

=== 3. Tuzatishlar ===
  traceback'lar tozalandi → tirik: 6
  tinglovchilar tozalandi → tirik: 3
  kesh tozalandi → tirik: 0, o'ldi: 30/30

=== 4. __del__ va weakref.finalize ===
    __del__: self hali mavjud — lekin tirilish mumkin, interpretator yopilishida kafolat yo'q
  finalize tirikmi: True, interpretator yopilishida ham chaqiriladi (atexit): True
    finalize: sorov-999 — self ga havola yo'q, faqat kerakli argumentlar
  obyekt o'lgach finalize tirikmi: False   (bir marta ishladi)

xatolar.append(e)                               # ❌ traceback → freym → lokallar

xatolar.append({"tur": type(e).__name__, "xabar": str(e),
                "iz": traceback.format_exception(e)})   # ✅ faqat matn

class Ulanish:
    def __del__(self):
        self.soket.close()                      # ❌ qachon chaqirilishi noma'lum (PyPy, sikl, yopilish)

    def __enter__(self): return self
    def __exit__(self, *e): self.soket.close()  # ✅ with bilan aniq

def __del__(self):
    jurnal.info("yopildi")                      # ❌ yopilishda jurnal allaqachon None bo'lishi mumkin

satr = next(fayl_oqimi(yol))                    # ❌ generator freymi faylni ochiq ushlaydi

if sys.getrefcount(obj) == 2: ...               # ❌ versiyaga va chaqiruv joyiga bog'liq

havola = weakref.ref(obj)
if havola() is None: ...                        # ✅

def sorovni_ishla():
    kesh = qur_katta_indeks()                   # 10 mln obyekt
    ...
    return javob                                # ⚠️ chiqishda butun indeks o'chiriladi — javob kechikadi

self.chaqiruvchi = inspect.currentframe().f_back    # ❌ butun chaqiruv zanjiri tirik
self.chaqiruvchi_nomi = inspect.currentframe().f_back.f_code.co_name   # ✅

hodisalar.append(self.yangila)                  # ❌ self abadiy tirik
hodisalar.append(weakref.WeakMethod(self.yangila))   # ✅

import sys

class R:
    def __init__(self, n):
        self.n = n
    def __del__(self):
        print("del", self.n, end=" ")
1.  r = R(1)
    del r
    print("keyin")
2.  r = R(1)
    r = R(2)
    print("|", end=" ")
    del r
    print()
3.  def f():
        t = R("f")
        print("ichkarida", end=" ")
    f()
    print("tashqarida")
4.  a = R("a")
    b = a
    del a
    print("hali", end=" ")
    del b
    print()
5.  l = [R("x")]
    l.clear()
    print("tozalandi")
6.  o = object()
    d = {1: o, 2: o}
    print(sys.getrefcount(o) - 1)
7.  def g():
        x = []
        return sys.getrefcount(x)
    print(g())
8.  saqla = []
    class T:
        def __del__(self):
            saqla.append(self)
            print("del", end=" ")
    t = T()
    del t
    saqla.clear()
    print(len(saqla))
9.  def f():
        obj = R("freym")
        raise ValueError
    try:
        f()
    except ValueError as e:
        saqlangan = e
    print("except dan keyin", end=" ")
    del saqlangan
    print()
10. import weakref
    r = R("w")
    w = weakref.ref(r)
    del r
    print(w())
11. a = R("ota")
    a.bola = R("bola")
    del a
    print()
12. def gen():
        obj = R("gen")
        yield 1
        yield 2
    g = gen()
    next(g)
    print("to'xtatildi", end=" ")
    del g
    print()

1.  class Jurnal:
        def __init__(self, yol):
            self.fayl = open(yol, "a")
        def __del__(self):
            self.fayl.close()

2.  so_nggi_xatolar = []
    def ishla(malumot):
        katta = yukla(malumot)
        try:
            return tahlil(katta)
        except Exception as e:
            so_nggi_xatolar.append(e)
            raise

3.  def birinchi_qator(yol):
        def oqi():
            with open(yol) as f:
                yield from f
        return next(oqi())

4.  class Hodisa:
        obunachilar = []
        def obuna(self, f):
            self.obunachilar.append(f)
    class Panel:
        def __init__(self, hodisa):
            hodisa.obuna(self.yangila)

5.  def tirikmi(obj):
        return sys.getrefcount(obj) > 2