11.5-dars: Axlat yig'uvchi (GC) va sikllar

class Tugun:
    def __init__(self, nom, ota=None):
        self.nom = nom
        self.ota = ota
        self.bolalar = []
        if ota:
            ota.bolalar.append(self)

ildiz = Tugun("html")
body = Tugun("body", ildiz)
del ildiz, body          # ildiz → body (bolalar), body → ildiz (ota) — sikl

tashqi nom ──► A ◄──► B        C ◄──► D
                                 (tashqaridan havola yo'q)
A: refcnt 2, ichki 1 → gc_refs 1 → tirik (B ham tirik)
C: refcnt 1, ichki 1 → gc_refs 0 → erishib bo'lmaydi

ota ↔ bola    oldingi ↔ keyingi    obj.men = obj
xato = e (freym ↔ traceback)    self.f = self.metod    rekursiv ichki funksiya

gc_refs = refcnt − ichki havolalar
gc_refs > 0 → tirik (va undan erishiladiganlar)
qolganlar → weakref tozalash → __del__ (bir marta) → havolalarni uzish

threshold (2000, 10, 10)    omon qolgan → keyingi avlod
gc.get_count()    gc.get_stats()    gc.callbacks

gc.disable(); yukla(); gc.enable(); gc.collect()
gc.freeze()                       # init / fork dan oldin
gc.set_threshold(50_000, 20, 20)  # ajratish ko'p, sikl kam

weakref.ref(ota)    del xato / finally    WeakMethod    clear()/close()

"""O'ziga havola, ota-bola, ikki tomonlama ro'yxat, istisno-freym va bog'langan metod sikllari; gc.collect topadi."""

import gc
import weakref

gc.collect()
gc.disable()                                   # avtomatik yig'ish natijani aralashtirmasin


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


def tekshir(tavsif, yaratuvchi):
    havolalar = yaratuvchi()
    tirik_oldin = sum(h() is not None for h in havolalar)
    topildi = gc.collect()
    tirik_keyin = sum(h() is not None for h in havolalar)
    print(f"  {tavsif:34} del dan keyin tirik: {tirik_oldin}/{len(havolalar)}, "
          f"gc.collect() → {topildi:>2} ta, keyin tirik: {tirik_keyin}")


def siklsiz():
    a, b = Tugun("a"), Tugun("b")
    a.b = b
    return [weakref.ref(a), weakref.ref(b)]


def ozi_havola():
    a = Tugun("a")
    a.men = a
    return [weakref.ref(a)]


def ota_bola():
    ota = Tugun("ota")
    ota.bolalar = [Tugun(f"bola{i}") for i in range(3)]
    for b in ota.bolalar:
        b.ota = ota
    return [weakref.ref(ota)] + [weakref.ref(b) for b in ota.bolalar]


def ikki_tomonlama():
    tugunlar = [Tugun(i) for i in range(5)]
    for chap, ong in zip(tugunlar, tugunlar[1:]):
        chap.keyingi, ong.oldingi = ong, chap
    return [weakref.ref(t) for t in tugunlar]


def istisno_freym():
    katta = Tugun("katta ma'lumot")
    try:
        raise ValueError("xato")
    except ValueError as e:
        xato = e                                # freym → xato → traceback → freym
    return [weakref.ref(katta)]


def istisno_freym_tozalangan():
    katta = Tugun("katta ma'lumot")
    try:
        raise ValueError("xato")
    except ValueError as e:
        xato = e
    del xato                                    # sikl uzildi
    return [weakref.ref(katta)]


class Tugma:
    def __init__(self):
        self.bosilganda = self.bos              # self → metod → __self__ → self

    def bos(self):
        return "bosildi"


def bogl_metod():
    return [weakref.ref(Tugma())]


print("=== Qaysi tuzilmalar sikl hosil qiladi ===")
for tavsif, f in [("sikl yo'q (a → b)", siklsiz), ("o'ziga havola", ozi_havola),
                  ("ota ↔ 3 bola", ota_bola), ("ikki tomonlama ro'yxat (5)", ikki_tomonlama),
                  ("⚠️ istisno lokal o'zgaruvchida", istisno_freym),
                  ("✅ del xato bilan", istisno_freym_tozalangan),
                  ("⚠️ self.f = self.metod", bogl_metod)]:
    tekshir(tavsif, f)

print("\n=== Sikl ichidagi __del__ (PEP 442) ===")


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

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


x, y = Resurs("x"), Resurs("y")
x.y, y.x = y, x
del x, y
print("  del dan keyin — hech narsa chaqirilmadi")
print(f"  gc.collect() → {gc.collect()}, gc.garbage: {gc.garbage}")
gc.enable()

=== Qaysi tuzilmalar sikl hosil qiladi ===
  sikl yo'q (a → b)                  del dan keyin tirik: 0/2, gc.collect() →  0 ta, keyin tirik: 0
  o'ziga havola                      del dan keyin tirik: 1/1, gc.collect() →  1 ta, keyin tirik: 0
  ota ↔ 3 bola                       del dan keyin tirik: 4/4, gc.collect() →  5 ta, keyin tirik: 0
  ikki tomonlama ro'yxat (5)         del dan keyin tirik: 5/5, gc.collect() →  5 ta, keyin tirik: 0
  ⚠️ istisno lokal o'zgaruvchida     del dan keyin tirik: 1/1, gc.collect() →  4 ta, keyin tirik: 0
  ✅ del xato bilan                   del dan keyin tirik: 0/1, gc.collect() →  0 ta, keyin tirik: 0
  ⚠️ self.f = self.metod             del dan keyin tirik: 1/1, gc.collect() →  2 ta, keyin tirik: 0

=== Sikl ichidagi __del__ (PEP 442) ===
  del dan keyin — hech narsa chaqirilmadi
    __del__ x
    __del__ y
  gc.collect() → 2, gc.garbage: []

"""gc_refs = refcnt − ichki havolalar: kichik graf uchun erishib bo'lmaydigan obyektlarni topish va gc bilan solishtirish."""

import ctypes
import gc
import weakref

gc.disable()


class Obyekt:
    def __init__(self, nom):
        self.nom = nom
        self.havolalar = []

    def __repr__(self):
        return self.nom


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


A, B, C, D, E = (Obyekt(n) for n in "ABCDE")
A.havolalar.append(B)
B.havolalar.append(A)
C.havolalar.append(D)
D.havolalar.append(C)
D.havolalar.append(E)
tashqi = [A]
guruh = [A, B, C, D, E]
nomlar = {id(o): o.nom for o in guruh}
zaif = {o.nom: weakref.ref(o) for o in guruh}


def ichki_obyektlar(o):
    """Obyekt → __dict__ → havolalar ro'yxati → obyektlar (bir qadamda ochib beramiz)."""
    return list(o.havolalar)


print("=== 1. Graf ===")
for o in guruh:
    print(f"  {o.nom} → {ichki_obyektlar(o)}")
print("  tashqaridan: tashqi ro'yxat → A")

del A, B, C, D, E, o, guruh


def gc_refs_hisobla():
    """Hisoblashning o'zi yaratgan vaqtinchalik havolalarni nazorat obyekti bilan o'lchab, ayiramiz."""
    # nazorat obyektining tashqi havolasi yo'q — unda faqat o'lchovning o'z havolalari bo'ladi
    obyektlar = [z() for z in zaif.values()] + [Obyekt("nazorat")]
    xom = {x.nom: refcnt(x) for x in obyektlar}
    ortiqcha = xom.pop("nazorat")
    natija = {nom: qiymat - ortiqcha for nom, qiymat in xom.items()}
    for x in obyektlar[:-1]:
        for ichki in ichki_obyektlar(x):
            natija[ichki.nom] -= 1
    return natija, ortiqcha


print("\n=== 2. gc_refs hisoblash ===")
gc_refs, ortiqcha = gc_refs_hisobla()
print(f"  o'lchovning o'z havolalari (nazorat obyektida): {ortiqcha}")
print(f"  refcnt − o'lchov − ichki havolalar: {gc_refs}")

tirik = set()
navbat = [nom for nom, qiymat in gc_refs.items() if qiymat > 0]
while navbat:
    nom = navbat.pop()
    if nom in tirik:
        continue
    tirik.add(nom)
    navbat.extend(i.nom for i in ichki_obyektlar(zaif[nom]()))
erishib_bolmaydi = sorted(set(gc_refs) - tirik)
print(f"  tashqaridan havolasi bor: {sorted(n for n, q in gc_refs.items() if q > 0)}")
print(f"  tirik (erishiladigan): {sorted(tirik)}")
print(f"  bizning bashorat — o'chiriladi: {erishib_bolmaydi}")

print("\n=== 3. Haqiqiy gc bilan solishtirish ===")
gc.collect()
haqiqiy = sorted(n for n, z in zaif.items() if z() is None)
print(f"  gc o'chirdi: {haqiqiy}, bashorat bilan bir xil: {haqiqiy == erishib_bolmaydi}")
del tashqi
gc.collect()
print(f"  tashqi havola olib tashlangach: o'lganlar {sorted(n for n, z in zaif.items() if z() is None)}")
gc.enable()

=== 1. Graf ===
  A → [B]
  B → [A]
  C → [D]
  D → [C, E]
  E → []
  tashqaridan: tashqi ro'yxat → A

=== 2. gc_refs hisoblash ===
  o'lchovning o'z havolalari (nazorat obyektida): 2
  refcnt − o'lchov − ichki havolalar: {'A': 1, 'B': 0, 'C': 0, 'D': 0, 'E': 0}
  tashqaridan havolasi bor: ['A']
  tirik (erishiladigan): ['A', 'B']
  bizning bashorat — o'chiriladi: ['C', 'D', 'E']

=== 3. Haqiqiy gc bilan solishtirish ===
  gc o'chirdi: ['C', 'D', 'E'], bashorat bilan bir xil: True
  tashqi havola olib tashlangach: o'lganlar ['A', 'B', 'C', 'D', 'E']

"""gc.get_count o'zgarishi, avtomatik yig'ishlarni callbacks bilan sanash, chegarani oshirish, disable va freeze ta'siri."""

import gc
import time
import weakref


class Tugun:
    pass


print("=== 1. Hisoblagichlar ===")
gc.collect()
print(f"  chegaralar: {gc.get_threshold()}, collect dan keyin: {gc.get_count()}")
vaqtincha = [[] for _ in range(1500)]
print(f"  1500 ro'yxat yaratildi: {gc.get_count()}")
vaqtincha2 = [[] for _ in range(1000)]
print(f"  yana 1000 ta (chegara 2000 dan oshdi): {gc.get_count()}   — 0-avlod yig'ildi, 1-avlodga +1")
del vaqtincha, vaqtincha2

print("\n=== 2. Avtomatik yig'ishlarni sanash ===")


def sana(chegara, soni=100_000):
    gc.collect()
    eski = gc.get_threshold()
    gc.set_threshold(*chegara)
    avlodlar = [0, 0, 0]

    def kuzat(bosqich, malumot):
        if bosqich == "start":
            avlodlar[malumot["generation"]] += 1

    gc.callbacks.append(kuzat)
    saqlanadi = [[i] for i in range(soni)]
    gc.callbacks.remove(kuzat)
    gc.set_threshold(*eski)
    return avlodlar


for chegara in [(2000, 10, 10), (50_000, 20, 20)]:
    print(f"  chegara {chegara}: 100 000 ro'yxat davomida yig'ishlar (0, 1, 2-avlod) = {sana(chegara)}")

print("\n=== 3. ⚠️ gc.disable() va sikllar ===")
gc.collect()
gc.disable()
havolalar = []
for i in range(1000):
    t = Tugun()
    t.men = t
    havolalar.append(weakref.ref(t))
del t
print(f"  1000 ta o'ziga havolali obyekt, GC o'chiq: tirik {sum(h() is not None for h in havolalar)}")
gc.enable()
gc.collect()
print(f"  gc.enable() + collect: tirik {sum(h() is not None for h in havolalar)}")

print("\n=== 4. freeze: uzoq yashaydigan obyektlarni tekshiruvdan chiqarish ===")
katta_kesh = [{"id": i, "teglar": [i]} for i in range(300_000)]


def olchov():
    bosh = time.perf_counter()
    gc.collect()
    return time.perf_counter() - bosh


oddiy = min(olchov() for _ in range(3))
gc.freeze()
muzlatilgan = min(olchov() for _ in range(3))
print(f"  muzlatilgan obyektlar: {gc.get_freeze_count() > 300_000}")
print(f"  freeze dan keyin to'liq yig'ish kamida 5 marta tezroq: {oddiy > 5 * muzlatilgan}")
gc.unfreeze()
del katta_kesh
gc.collect()

=== 1. Hisoblagichlar ===
  chegaralar: (2000, 10, 10), collect dan keyin: (4, 0, 0)
  1500 ro'yxat yaratildi: (1506, 0, 0)
  yana 1000 ta (chegara 2000 dan oshdi): (506, 1, 0)   — 0-avlod yig'ildi, 1-avlodga +1

=== 2. Avtomatik yig'ishlarni sanash ===
  chegara (2000, 10, 10): 100 000 ro'yxat davomida yig'ishlar (0, 1, 2-avlod) = [45, 4, 0]
  chegara (50000, 20, 20): 100 000 ro'yxat davomida yig'ishlar (0, 1, 2-avlod) = [2, 0, 0]

=== 3. ⚠️ gc.disable() va sikllar ===
  1000 ta o'ziga havolali obyekt, GC o'chiq: tirik 1000
  gc.enable() + collect: tirik 0

=== 4. freeze: uzoq yashaydigan obyektlarni tekshiruvdan chiqarish ===
  muzlatilgan obyektlar: True
  freeze dan keyin to'liq yig'ish kamida 5 marta tezroq: True

"""Ota havolasi: kuchli (sikl) va zaif (weakref.ref); GC o'chiq holatda sizish; property orqali qulay API; tozalash."""

import gc
import weakref


class KuchliTugun:
    tiriklar = weakref.WeakSet()

    def __init__(self, teg, ota=None):
        self.teg = teg
        self.ota = ota
        self.bolalar = []
        if ota is not None:
            ota.bolalar.append(self)
        KuchliTugun.tiriklar.add(self)

    def yol(self):
        qismlar, t = [], self
        while t is not None:
            qismlar.append(t.teg)
            t = t.ota
        return "/".join(reversed(qismlar))


class ZaifTugun:
    tiriklar = weakref.WeakSet()

    def __init__(self, teg, ota=None):
        self.teg = teg
        self._ota = weakref.ref(ota) if ota is not None else None
        self.bolalar = []
        if ota is not None:
            ota.bolalar.append(self)
        ZaifTugun.tiriklar.add(self)

    @property
    def ota(self):
        return self._ota() if self._ota is not None else None

    def yol(self):
        qismlar, t = [], self
        while t is not None:
            qismlar.append(t.teg)
            t = t.ota
        return "/".join(reversed(qismlar))


def sahifa_qur(klass, raqam):
    html = klass("html")
    body = klass("body", html)
    for i in range(20):
        div = klass(f"div{i}", body)
        klass("p", div)
        klass("a", div)
    return html.bolalar[0].bolalar[raqam % 20].bolalar[1].yol()


print("=== 1. Bir xil API ===")
for klass in (KuchliTugun, ZaifTugun):
    print(f"  {klass.__name__}: {sahifa_qur(klass, 7)}")

print("\n=== 2. GC o'chiq holatda 100 ta sahifa ===")
gc.collect()
gc.disable()
for klass in (KuchliTugun, ZaifTugun):
    for i in range(100):
        sahifa_qur(klass, i)
    print(f"  {klass.__name__:12} xotirada qolgan tugunlar: {len(klass.tiriklar):>5}   (bir sahifa — 62 tugun)")
gc.enable()
topildi = gc.collect()
print(f"  gc.collect(): {topildi} ta obyekt yig'ildi → KuchliTugun qoldi: {len(KuchliTugun.tiriklar)}")

print("\n=== 3. ⚠️ Zaif ota — daraxt ildizini ushlab turish kerak ===")
bola = ZaifTugun("span", ZaifTugun("div"))
print(f"  ota vaqtinchalik edi: bola.ota = {bola.ota}, yol = {bola.yol()!r}")
div = ZaifTugun("div")
bola2 = ZaifTugun("span", div)
print(f"  ota nomda saqlandi: yol = {bola2.yol()!r}")

print("\n=== 4. Kuzatuv: yig'ishlarni callbacks bilan jurnallash ===")
jurnal = []


def kuzat(bosqich, malumot):
    if bosqich == "stop" and malumot["collected"]:
        jurnal.append((malumot["generation"], malumot["collected"]))


gc.collect()
gc.callbacks.append(kuzat)
for i in range(200):
    sahifa_qur(KuchliTugun, i)
gc.collect()
gc.callbacks.remove(kuzat)
yigilgan = sum(s for _, s in jurnal)
print(f"  200 kuchli sahifa: {len(jurnal)} ta yig'ish obyekt topdi, jami {yigilgan} ta obyekt")
print(f"  avlodlar bo'yicha: { {a: sum(s for g, s in jurnal if g == a) for a in (0, 1, 2)} }")

=== 1. Bir xil API ===
  KuchliTugun: html/body/div7/a
  ZaifTugun: html/body/div7/a

=== 2. GC o'chiq holatda 100 ta sahifa ===
  KuchliTugun  xotirada qolgan tugunlar:  6200   (bir sahifa — 62 tugun)
  ZaifTugun    xotirada qolgan tugunlar:     0   (bir sahifa — 62 tugun)
  gc.collect(): 18600 ta obyekt yig'ildi → KuchliTugun qoldi: 0

=== 3. ⚠️ Zaif ota — daraxt ildizini ushlab turish kerak ===
  ota vaqtinchalik edi: bola.ota = None, yol = 'span'
  ota nomda saqlandi: yol = 'div/span'

=== 4. Kuzatuv: yig'ishlarni callbacks bilan jurnallash ===
  200 kuchli sahifa: 18 ta yig'ish obyekt topdi, jami 37200 ta obyekt
  avlodlar bo'yicha: {0: 30318, 1: 3906, 2: 2976}

bola.ota = ota                          # ❌ har tugun sikl — faqat GC tozalaydi

bola._ota = weakref.ref(ota)            # ✅ property orqali ota() ni qaytaring

except ValueError as e:
    oxirgi_xato = e                     # ❌ freym ↔ traceback sikli
    ...

except ValueError as e:
    oxirgi_xato = str(e)                # ✅ yoki funksiya oxirida del oxirgi_xato

self.ishlovchi = self.qayta_ishla       # ❌ sikl

def ishlovchi(self, *a):                # ✅ oddiy metod chaqiring yoki WeakMethod
    return self.qayta_ishla(*a)

gc.disable()                            # ❌ "tezlashtirish" — sekin xotira sizishi

def javob_ber(sorov):
    ...
    gc.collect()                        # ❌ to'liq yig'ish — har so'rovga o'nlab ms

model = yukla_katta_model()             # millionlab obyekt
# ❌ har to'liq yig'ish ularni qayta tekshiradi

gc.freeze()                             # ✅ yuklangandan keyin

def __del__(self):
    self.sherik.yop()                   # ❌ sherik allaqachon tozalangan bo'lishi mumkin

print(gc.garbage)                       # ❌ zamonaviy Python'da deyarli har doim bo'sh

gc.set_debug(gc.DEBUG_SAVEALL); gc.collect()   # ✅ yig'ilganlarni ko'rish (faqat tuzatishda)

import gc, weakref

class T:
    pass

gc.collect()
1.  a = T()
    a.me = a
    w = weakref.ref(a)
    del a
    print(w() is None)
2.  gc.collect()
    print(w() is None)
3.  b = T()
    c = T()
    b.c = c
    w2 = weakref.ref(b)
    del b, c
    print(w2() is None)
4.  print(gc.is_tracked(1), gc.is_tracked([]), gc.is_tracked("s"))
5.  print(gc.is_tracked(0.5), gc.is_tracked(T()))
6.  print(gc.get_threshold()[0])
7.  gc.disable()
    x = T()
    x.x = x
    wx = weakref.ref(x)
    del x
    print(gc.isenabled(), wx() is None)
8.  print(gc.collect() >= 1, wx() is None)
    gc.enable()
9.  class Q:
        def __init__(self, ota):
            self.ota = weakref.ref(ota)
    class P:
        def __init__(self):
            self.bola = Q(self)
    p = P()
    wp = weakref.ref(p)
    del p
    print(wp() is None)
10. print(gc.garbage)
11. gc.freeze()
    print(gc.get_freeze_count() > 0)
    gc.unfreeze()
12. def f():
        t = T()
        try:
            1 / 0
        except ZeroDivisionError as e:
            xato = e
        return weakref.ref(t)
    wt = f()
    print(wt() is None, end=" ")
    gc.collect()
    print(wt() is None)

1.  class Menyu:
        def __init__(self, nom, ota=None):
            self.nom, self.ota, self.bolalar = nom, ota, []
            if ota:
                ota.bolalar.append(self)

2.  def yuklash():
        gc.disable()
        return [yukla(f) for f in fayllar]

3.  def qayta_urin(f):
        oxirgi = None
        for _ in range(3):
            try:
                return f()
            except IOError as e:
                oxirgi = e
        raise oxirgi

4.  class Kuzatuvchi:
        def __init__(self, manba):
            self.manba = manba
            manba.obunachilar.append(self.yangila)

5.  @app.after_request
    def tozala(javob):
        gc.collect()
        return javob