12.3-dars: Frame va chaqiruv steki

except Exception as xato:
    self.xatolar.append(xato)

 ┌─────────────── freym: hisobla(3) ───────────────┐
 │ kod obyekti      → hisobla.__code__  (12.1)     │
 │ globallar        → modul __dict__               │
 │ builtins         → builtins.__dict__            │
 │ lokal va hujayralar massivi: [soni, narx, jami] │  ← LOAD_FAST indeks bo'yicha
 │ qiymatlar steki:  [ ... ]  (co_stacksize)       │  ← 12.2 dagi stek
 │ joriy instruksiya → f_lasti                     │
 │ oldingi freym    → chaqiruvchi (f_back)         │
 └─────────────────────────────────────────────────┘

def a(): b()
def b(): c()
def c(): ...        # shu yerda stek:  c ← b ← a ← <module>

def f():
    x = 1
    sys._getframe().f_locals["x"] = 2    # x endi 2 — proksi orqali yozildi
    locals()["x"] = 3                    # hech narsa — nusxaga yozildi
    return x                             # 2

xato.__traceback__           tb (<module>, qator 30)
    .tb_next                 tb (ishlov_ber, qator 12)
        .tb_next             tb (hisobla, qator 5)   ← xato shu yerda
            .tb_next         None

sys._getframe(0|1|n)     inspect.currentframe()
inspect.stack(context=0) traceback.extract_stack(limit=n)
sys._getframemodulename(1)

f_code f_locals f_globals f_builtins f_back f_lineno f_lasti f_trace f_generator clear()

frame.f_locals  → funksiyada proksi: yozish haqiqiy, o'chirish ValueError
locals()        → nusxa

xato.__traceback__ → tb_frame, tb_lineno, tb_next
traceback.format_exception(xato)   traceback.clear_frames(tb)
except ... as xato: → blok oxirida xato o'chiriladi

sys.getrecursionlimit() → 1000     RecursionError     tail call yo'q → sikl + stek

"""Joriy freym atributlari; f_back zanjiri; inspect.stack; qaytgandan keyin yashaydigan freym; generator freymi holatlari."""

import dis
import inspect
import sys


def stek_zanjiri():
    natija = []
    freym = sys._getframe(1)
    while freym is not None:
        natija.append(f"{freym.f_code.co_qualname}:+{freym.f_lineno - freym.f_code.co_firstlineno}")
        freym = freym.f_back
    return natija


class Buyurtma:
    def __init__(self, narx, soni):
        self.narx, self.soni = narx, soni

    def jami(self):
        chegirma = 0.1
        return self._hisobla(chegirma)

    def _hisobla(self, chegirma):
        oraliq = self.narx * self.soni
        global SAQLANGAN
        SAQLANGAN = sys._getframe()
        print("=== 1. Joriy freym ===")
        f = SAQLANGAN
        print(f"  f_code.co_qualname: {f.f_code.co_qualname}")
        print(f"  f_locals kalitlari: {sorted(f.f_locals)}")
        print(f"  f_globals is modul globallari: {f.f_globals is globals()}, f_builtins da 'len': {'len' in f.f_builtins}")
        instr = next(i for i in dis.get_instructions(f.f_code) if i.offset == f.f_lasti)
        print(f"  f_lineno: +{f.f_lineno - f.f_code.co_firstlineno}, f_lasti: {f.f_lasti} → {instr.opname}")
        print(f"  f_back: {f.f_back.f_code.co_qualname}")

        print("\n=== 2. Chaqiruv steki ===")
        print(f"  f_back zanjiri: {stek_zanjiri()}")
        print(f"  inspect.stack(context=0): {[(k.function, k.lineno - k.frame.f_code.co_firstlineno) for k in inspect.stack(context=0)]}")
        print(f"  chaqiruvchi modul: {sys._getframemodulename(1)}")
        return oraliq * (1 - chegirma)


def asosiy():
    return Buyurtma(15_000, 4).jami()


natija = asosiy()

print("\n=== 3. Qaytgandan keyin freym ===")
print(f"  natija: {natija}")
tirik = SAQLANGAN.f_locals
print(f"  saqlangan freym lokallari hali tirik: {sorted(tirik)}, chegirma={tirik['chegirma']}, oraliq={tirik['oraliq']}, self turi {type(tirik['self']).__name__}")
SAQLANGAN.clear()
print(f"  clear() dan keyin: {dict(SAQLANGAN.f_locals)}")

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


def sanagich(n):
    for i in range(n):
        yield i, sys._getframe().f_back.f_code.co_name


def iste_molchi_a(g):
    return next(g)


def iste_molchi_b(g):
    return next(g)


g = sanagich(3)
print(f"  yaratildi: {inspect.getgeneratorstate(g)}, gi_frame.f_back: {g.gi_frame.f_back}")
print(f"  a orqali: {iste_molchi_a(g)}, b orqali: {iste_molchi_b(g)}  ← freym har safar boshqa joyga ulandi")
print(f"  to'xtagan: {inspect.getgeneratorstate(g)}, gi_frame.f_back: {g.gi_frame.f_back}, f_generator is g: {g.gi_frame.f_generator is g}")
g.close()
print(f"  yopilgan: {inspect.getgeneratorstate(g)}, gi_frame: {g.gi_frame}")

=== 1. Joriy freym ===
  f_code.co_qualname: Buyurtma._hisobla
  f_locals kalitlari: ['chegirma', 'f', 'oraliq', 'self']
  f_globals is modul globallari: True, f_builtins da 'len': True
  f_lineno: +10, f_lasti: 568 → CALL
  f_back: Buyurtma.jami

=== 2. Chaqiruv steki ===
  f_back zanjiri: ['Buyurtma._hisobla:+14', 'Buyurtma.jami:+2', 'asosiy:+1', '<module>:+48']
  inspect.stack(context=0): [('_hisobla', 15), ('jami', 2), ('asosiy', 1), ('<module>', 48)]
  chaqiruvchi modul: __main__

=== 3. Qaytgandan keyin freym ===
  natija: 54000.0
  saqlangan freym lokallari hali tirik: ['chegirma', 'f', 'instr', 'oraliq', 'self'], chegirma=0.1, oraliq=60000, self turi Buyurtma
  clear() dan keyin: {}

=== 4. Generator freymi ===
  yaratildi: GEN_CREATED, gi_frame.f_back: None
  a orqali: (0, 'iste_molchi_a'), b orqali: (1, 'iste_molchi_b')  ← freym har safar boshqa joyga ulandi
  to'xtagan: GEN_SUSPENDED, gi_frame.f_back: None, f_generator is g: True
  yopilgan: GEN_CLOSED, gi_frame: None

"""PEP 667: proksi yozadi, locals() nusxa; closure o'zgaruvchisi; chaqiruvchi lokalini o'zgartirish; rekursiya chegarasi; rekursiyadan siklga."""

import sys


print("=== 1. f_locals proksi va locals() nusxa ===")


def tajriba():
    x = 1
    proksi = sys._getframe().f_locals
    nusxa = locals()
    proksi["x"] = 2
    holat_proksi = x
    nusxa["x"] = 3
    holat_nusxa = x
    proksi["yangi_nom"] = "salom"
    try:
        del proksi["x"]
        ochirish = "o'chirildi"
    except ValueError as xato:
        ochirish = f"ValueError: {xato}"
    return type(proksi).__name__, type(nusxa).__name__, holat_proksi, holat_nusxa, proksi["yangi_nom"], ochirish


for nom, qiymat in zip(["proksi turi", "locals() turi", "proksi orqali yozgach x", "nusxaga yozgach x",
                        "yangi kalit proksida", "lokalni o'chirish"], tajriba()):
    print(f"  {nom:26} {qiymat}")
print(f"  modul darajasida f_locals is globals(): {sys._getframe().f_locals is globals()}")


def tashqi():
    hisob = 10

    def ichki():
        return hisob

    sys._getframe().f_locals["hisob"] = 99
    return ichki()


print(f"  closure o'zgaruvchisi proksi orqali: ichki() → {tashqi()}")

print("\n=== 2. Chaqiruvchining lokalini o'zgartirish (debugger kabi) ===")


def sozla(nom, qiymat):
    sys._getframe(1).f_locals[nom] = qiymat


def xizmat():
    rejim = "prod"
    sozla("rejim", "debug")
    return rejim


print(f"  xizmat() → {xizmat()!r}  ⚠️ ishlaydi, lekin kodni o'qib bo'lmas qiladi")

print("\n=== 3. Rekursiya chegarasi ===")
chuqurlik = 0


def chuqur(n):
    global chuqurlik
    chuqurlik = n
    return chuqur(n + 1)


print(f"  getrecursionlimit: {sys.getrecursionlimit()}")
for chegara in (100, 1000):
    sys.setrecursionlimit(chegara)
    try:
        chuqur(1)
    except RecursionError as xato:
        print(f"  chegara {chegara}: {chuqurlik} qavatda RecursionError: {xato}")
sys.setrecursionlimit(1000)

print("\n=== 4. Rekursiyadan siklga ===")


def daraxt(chuqurlik_):
    ildiz = {"nom": "0", "bolalar": []}
    tugun = ildiz
    for i in range(1, chuqurlik_):
        yangi = {"nom": str(i), "bolalar": []}
        tugun["bolalar"].append(yangi)
        tugun = yangi
    return ildiz


def tugunlar_rekursiv(t):
    return 1 + sum(tugunlar_rekursiv(b) for b in t["bolalar"])


def tugunlar_sikl(t):
    soni, stek = 0, [t]
    while stek:
        joriy = stek.pop()
        soni += 1
        stek.extend(joriy["bolalar"])
    return soni


chiziq = daraxt(5000)
try:
    tugunlar_rekursiv(chiziq)
except RecursionError:
    print("  rekursiv: 5000 qavatli daraxtda RecursionError")
print(f"  sikl + aniq stek: {tugunlar_sikl(chiziq)} tugun")
kichik = daraxt(50)
print(f"  kichik daraxtda ikkalasi teng: {tugunlar_rekursiv(kichik) == tugunlar_sikl(kichik) == 50}")

=== 1. f_locals proksi va locals() nusxa ===
  proksi turi                FrameLocalsProxy
  locals() turi              dict
  proksi orqali yozgach x    2
  nusxaga yozgach x          2
  yangi kalit proksida       salom
  lokalni o'chirish          ValueError: cannot remove local variables from FrameLocalsProxy
  modul darajasida f_locals is globals(): True
  closure o'zgaruvchisi proksi orqali: ichki() → 99

=== 2. Chaqiruvchining lokalini o'zgartirish (debugger kabi) ===
  xizmat() → 'debug'  ⚠️ ishlaydi, lekin kodni o'qib bo'lmas qiladi

=== 3. Rekursiya chegarasi ===
  getrecursionlimit: 1000
  chegara 100: 99 qavatda RecursionError: maximum recursion depth exceeded
  chegara 1000: 999 qavatda RecursionError: maximum recursion depth exceeded

=== 4. Rekursiyadan siklga ===
  rekursiv: 5000 qavatli daraxtda RecursionError
  sikl + aniq stek: 5000 tugun
  kichik daraxtda ikkalasi teng: True

"""Traceback zanjiri; except-as nomining o'chirilishi; saqlangan istisno katta obyektni ushlashi; format_exception, TracebackException, clear_frames."""

import gc
import traceback
import tracemalloc
import weakref


def hisobla(jadval):
    return jadval["ustun"] / 0


class Malumot:
    def __init__(self, n):
        self.baytlar = bytearray(n)


def ishlov_ber(n):
    jadval = {"ustun": 1, "malumot": Malumot(n)}
    return hisobla(jadval)


print("=== 1. Traceback zanjiri ===")
try:
    ishlov_ber(10)
except ZeroDivisionError as xato:
    tb = xato.__traceback__
    zanjir = []
    while tb is not None:
        zanjir.append(f"{tb.tb_frame.f_code.co_name}:+{tb.tb_lineno - tb.tb_frame.f_code.co_firstlineno}")
        tb = tb.tb_next
    print(f"  tashqidan ichkariga: {zanjir}")
    oxirgi = traceback.extract_tb(xato.__traceback__)[-1]
    print(f"  extract_tb oxirgisi: {oxirgi.name}, qator matni: {oxirgi.line!r}")
    ichki_freym = xato.__traceback__.tb_next.tb_next.tb_frame
    print(f"  xato freymining lokallari: {sorted(ichki_freym.f_locals)}")
print(f"  except blokidan keyin 'xato' nomi bormi: {'xato' in globals()}")

print("\n=== 2. Saqlangan istisnolar katta ma'lumotni ushlaydi ===")


class Ishchi:
    def __init__(self):
        self.xatolar = []

    def vazifa(self, n):
        try:
            ishlov_ber(n)
        except ZeroDivisionError as xato:
            self.xatolar.append(xato)


def olchov(ishchi, saqlash_usuli):
    gc.collect()
    tracemalloc.start()
    for _ in range(20):
        ishchi.vazifa(1_000_000)
        if saqlash_usuli is not None:
            ishchi.xatolar[-1] = saqlash_usuli(ishchi.xatolar[-1])
    joriy, _ = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    return joriy / 1e6


def matn(xato):
    return "".join(traceback.format_exception(xato))


def tuzilgan(xato):
    return traceback.TracebackException.from_exception(xato)


def freymsiz(xato):
    traceback.clear_frames(xato.__traceback__)
    return xato


for tavsif, usul in [("istisno obyektini o'zi", None), ("format_exception matni", matn),
                     ("TracebackException", tuzilgan), ("clear_frames bilan", freymsiz)]:
    print(f"  {tavsif:24} 20 ta 1 MB li vazifadan keyin: {olchov(Ishchi(), usul):6.2f} MB")

print("\n=== 3. Qaysi obyekt ushlab turibdi ===")
ishchi = Ishchi()
ishchi.vazifa(100)
jadval_ref = weakref.ref(ishchi.xatolar[0].__traceback__.tb_next.tb_frame.f_locals["jadval"]["malumot"])
print(f"  jadval['malumot'] tirik: {jadval_ref() is not None}")
tuzilgan_xato = traceback.TracebackException.from_exception(ishchi.xatolar[0])
ishchi.xatolar.clear()
gc.collect()
print(f"  xatolar tozalangach tirik: {jadval_ref() is not None}")
print(f"  TracebackException hali ham hisobot bera oladi: {list(tuzilgan_xato.format())[-1].strip()!r}")

=== 1. Traceback zanjiri ===
  tashqidan ichkariga: ['<module>:+24', 'ishlov_ber:+2', 'hisobla:+1']
  extract_tb oxirgisi: hisobla, qator matni: 'return jadval["ustun"] / 0'
  xato freymining lokallari: ['jadval']
  except blokidan keyin 'xato' nomi bormi: False

=== 2. Saqlangan istisnolar katta ma'lumotni ushlaydi ===
  istisno obyektini o'zi   20 ta 1 MB li vazifadan keyin:  20.03 MB
  format_exception matni   20 ta 1 MB li vazifadan keyin:   0.02 MB
  TracebackException       20 ta 1 MB li vazifadan keyin:   0.02 MB
  clear_frames bilan       20 ta 1 MB li vazifadan keyin:   0.02 MB

=== 3. Qaysi obyekt ushlab turibdi ===
  jadval['malumot'] tirik: True
  xatolar tozalangach tirik: False
  TracebackException hali ham hisobot bera oladi: 'ZeroDivisionError: division by zero'

"""kor(*ifodalar): freym → CALL positions → manba → ast argumentlar; ko'p qatorli chaqiruv; qiymatni qaytaradi; logging stacklevel."""

import ast
import dis
import linecache
import logging
import sys


def kor(*qiymatlar):
    freym = sys._getframe(1)
    kod = freym.f_code
    instr = next(i for i in dis.get_instructions(kod) if i.offset == freym.f_lasti)
    p = instr.positions
    qatorlar = [linecache.getline(kod.co_filename, n) for n in range(p.lineno, p.end_lineno + 1)]
    if len(qatorlar) == 1:
        manba = qatorlar[0][p.col_offset:p.end_col_offset]
    else:
        manba = qatorlar[0][p.col_offset:] + "".join(qatorlar[1:-1]) + qatorlar[-1][:p.end_col_offset]
    chaqiruv = ast.parse(manba.strip(), mode="eval").body
    matnlar = [ast.unparse(arg) for arg in chaqiruv.args]
    joy = f"{kod.co_qualname}:+{p.lineno - kod.co_firstlineno}"
    juftlar = ", ".join(f"{m} = {q!r}" for m, q in zip(matnlar, qiymatlar))
    print(f"  kor| {joy} | {juftlar}")
    return qiymatlar[0] if len(qiymatlar) == 1 else qiymatlar


def buyurtma(narx, soni, chegirma=0.0):
    kor(narx, soni)
    jami = kor(narx * soni * (1 - chegirma))
    kor(
        jami > 100_000,
        round(jami / soni, 2),
    )
    return jami


class Savat:
    def __init__(self):
        self.mahsulotlar = {"olma": 3, "nok": 2}

    def soni(self):
        return kor(sum(self.mahsulotlar.values()))


print("=== 1. kor() ===")
natija = buyurtma(45_000, 3, chegirma=0.1)
Savat().soni()
print(f"  qaytgan qiymat ishlatildi: natija = {natija}")

print("\n=== 2. logging va stacklevel ===")


class QatorFormat(logging.Formatter):
    def format(self, yozuv):
        return f"  log| {yozuv.funcName}:{yozuv.lineno} | {yozuv.getMessage()}"


handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(QatorFormat())
log = logging.getLogger("demo")
log.addHandler(handler)
log.setLevel(logging.INFO)
log.propagate = False


def audit_oddiy(xabar):
    log.info(xabar)


def audit_togri(xabar):
    log.info(xabar, stacklevel=2)


def tolov_qabul(summa):
    audit_oddiy(f"to'lov: {summa} (stacklevel yo'q)")
    audit_togri(f"to'lov: {summa} (stacklevel=2)")


tolov_qabul(250_000)
qator_oddiy = audit_oddiy.__code__.co_firstlineno + 1
qator_tolov = tolov_qabul.__code__.co_firstlineno + 1
print(f"  audit_oddiy ichidagi log.info qatori: {qator_oddiy}; tolov_qabul dagi chaqiruvlar: {qator_tolov}, {qator_tolov + 1}")

=== 1. kor() ===
  kor| buyurtma:+1 | narx = 45000, soni = 3
  kor| buyurtma:+2 | narx * soni * (1 - chegirma) = 121500.0
  kor| buyurtma:+3 | jami > 100000 = True, round(jami / soni, 2) = 40500.0
  kor| Savat.soni:+1 | sum(self.mahsulotlar.values()) = 5
  qaytgan qiymat ishlatildi: natija = 121500.0

=== 2. logging va stacklevel ===
  log| audit_oddiy:68 | to'lov: 250000 (stacklevel yo'q)
  log| tolov_qabul:77 | to'lov: 250000 (stacklevel=2)
  audit_oddiy ichidagi log.info qatori: 68; tolov_qabul dagi chaqiruvlar: 76, 77

self.xatolar.append(xato)                               # ❌ freymlar va lokallar tirik
self.xatolar.append(traceback.TracebackException.from_exception(xato))   # ✅

self._chaqiruvchi = sys._getframe(1)                   # ❌ butun zanjir va lokallar tirik
self._chaqiruvchi = sys._getframe(1).f_code.co_qualname   # ✅ faqat kerakli ma'lumot

def log(xabar):
    chaqiruvchi = inspect.stack()[1].function         # ❌ har chaqiruvda fayllarni o'qiydi
    chaqiruvchi = sys._getframe(1).f_code.co_name     # ✅

def f():
    locals()["natija"] = 5
    return natija                                      # ❌ NameError

sys.setrecursionlimit(1_000_000)                       # ❌ C darajasida stek to'lishi

def ogohlantir(xabar):
    warnings.warn(xabar, DeprecationWarning)           # ⚠️ ogohlantirish o'rovchi qatorini ko'rsatadi
    warnings.warn(xabar, DeprecationWarning, stacklevel=2)   # ✅ chaqiruvchini

try:
    ...
except ValueError as xato:
    pass
print(xato)                                            # ❌ NameError

def gen():
    chaqiruvchi = sys._getframe(1)                     # ⚠️ har next() da boshqa bo'lishi mumkin

import sys
import inspect
import traceback
1.  def f():
        return sys._getframe().f_code.co_name
    print(f())
2.  def g():
        return sys._getframe(1).f_code.co_name
    def h():
        return g()
    print(h())
3.  def k():
        x = 1
        locals()["x"] = 2
        return x
    print(k())
4.  def m():
        x = 1
        sys._getframe().f_locals["x"] = 2
        return x
    print(m())
5.  print(type(sys._getframe().f_locals).__name__)
6.  def gen():
        yield sys._getframe().f_back is not None
    print(next(gen()))
7.  try:
        1 / 0
    except ZeroDivisionError as e:
        pass
    print("e" in dir())
8.  print(sys.getrecursionlimit())
9.  def t():
        raise ValueError("x")
    try:
        t()
    except ValueError as xato:
        tb = xato.__traceback__
    print(tb.tb_next.tb_frame.f_code.co_name)
10. print(len(traceback.extract_tb(tb)))
11. def p():
        return inspect.stack()[0].function
    print(p())
12. def q():
        fr = sys._getframe()
        try:
            del fr.f_locals["fr"]
        except ValueError:
            return "ValueError"
    print(q())

1.  class Hisobot:
        def __init__(self):
            self.xatolar = []
        def ishlat(self, vazifa):
            try:
                vazifa()
            except Exception as e:
                self.xatolar.append(e)

2.  def joriy_funksiya():
        return inspect.stack()[1][3]      # har so'rovda chaqiriladi

3.  def eskirgan(funksiya):
        def orov(*a, **k):
            warnings.warn(f"{funksiya.__name__} eskirgan", DeprecationWarning)
            return funksiya(*a, **k)
        return orov

4.  def tugunlar(t):
        return 1 + sum(tugunlar(b) for b in t.bolalar)   # 100 000 qavatli daraxt

5.  def sozlamalar():
        for k, v in os.environ.items():
            if k.startswith("APP_"):
                locals()[k.lower()] = v
        return app_port