8.6-dars: Meros asoslari

class Jangchi:
    def __init__(self, nom, jon):
        self.nom, self.jon = nom, jon
    def zarar(self, n): self.jon = max(0, self.jon - n)
    def tirikmi(self): return self.jon > 0
    def hujum(self): return 15

class Kamonchi:
    def __init__(self, nom, jon):
        self.nom, self.jon = nom, jon           # ⚠️ takror
    def zarar(self, n): self.jon = max(0, self.jon - n)   # ⚠️ takror
    def tirikmi(self): return self.jon > 0      # ⚠️ takror
    def hujum(self): return 12                  # ← faqat shu farq qiladi

class Jonzot:
    def __init__(self, nom, jon):
        self.nom, self.jon = nom, jon
    def zarar(self, n): self.jon = max(0, self.jon - n)
    def tirikmi(self): return self.jon > 0
    def hujum(self): raise NotImplementedError

class Jangchi(Jonzot):
    def hujum(self): return 15

class Kamonchi(Jonzot):
    def hujum(self): return 12

class Kvadrat(Togriturtburchak):        # ⚠️ mashhur muammo
    ...

class Foydalanuvchi(dict):              # ⚠️ ehtiyot
    ...

class A(B, C, D, E):                    # ⚠️ MRO chalkashligi
    ...

class Ota:
    def f(self): return "ota-f"
    def g(self): return "ota-g"


class Bola(Ota):                        # Ota dan meros
    def g(self): return "bola-g"        # qayta aniqlash (override)
    def h(self): return "bola-h"        # yangi metod


b = Bola()
b.f()                                   # 'ota-f'   ← Ota dan
b.g()                                   # 'bola-g'  ← qayta aniqlangan
b.h()                                   # 'bola-h'  ← yangi

class A: pass
class A(object): pass                   # ≡ bir xil

A.__bases__                             # (<class 'object'>,)
A.__mro__                               # (A, object)

# ✅ To'g'ri
class Hayvon: ...
class It(Hayvon): ...           # It — bu Hayvon ✅

class Istisno(Exception): ...   # Istisno — bu Exception ✅
class Admin(Foydalanuvchi): ... # Admin — bu Foydalanuvchi ✅

# ❌ Noto'g'ri
class Dvigatel: ...
class Mashina(Dvigatel): ...    # Mashina — bu Dvigatel EMAS
                                # Mashinada dvigatel BOR (has-a)

class Stack(list): ...          # ⚠️ Stack — list emas
                                # Stack ichida list BOR

class Togriturtburchak:
    def __init__(self, en, boy):
        self.en, self.boy = en, boy

    def yuza(self): return self.en * self.boy


class Kvadrat(Togriturtburchak):        # ⚠️ matematik "is-a"
    def __init__(self, tomon):
        super().__init__(tomon, tomon)

    @Togriturtburchak.en.setter         # tomonlar bog'liq bo'lishi kerak
    def en(self, q):
        self._en = self._boy = q


def test(t: Togriturtburchak):
    t.en = 5
    t.boy = 4
    assert t.yuza() == 20               # ⚠️ Kvadrat uchun 16!

# 1. O'zgarmas qilish — muammo yo'qoladi
@dataclass(frozen=True)
class Togriturtburchak:
    en: float
    boy: float

@dataclass(frozen=True)
class Kvadrat(Togriturtburchak):
    def __init__(self, tomon):
        super().__init__(tomon, tomon)      # ✅ o'zgarmaydi

# 2. Umumiy ota-sinf
class Shakl(ABC):
    @abstractmethod
    def yuza(self): ...

class Togriturtburchak(Shakl): ...
class Kvadrat(Shakl): ...                   # ✅ birodar, avlod emas

# ⚠️ 1. Avlodda NotImplementedError
class Bola(Ota):
    def metod(self):
        raise NotImplementedError("Bola bu metodni qo'llamaydi")

# ⚠️ 2. Avlod shartni qattiqlashtiradi
class Ota:
    def f(self, x: int): ...
class Bola(Ota):
    def f(self, x: int):
        if x < 0: raise ValueError(...)     # ⚠️ Ota qabul qilardi

# ⚠️ 3. isinstance tekshiruvlari paydo bo'ladi
if isinstance(x, Kvadrat): ...              # ⚠️ polimorfizm buzilgan

# ⚠️ 4. Avlod ota-sinf invariantini buzadi

class Ota:
    def f(self): return "ota"

class Bola(Ota):
    def f(self): return "bola"          # ota-sinf mantiqi ishlatilmaydi

class Bola(Ota):
    def f(self):
        natija = super().f()            # ⭐ ota-sinf mantiqi
        return f"{natija} + bola"

class Bola(Ota):
    def oldin(self):
        self.tayyorla()                 # oldin
        return super().oldin()

    def keyin(self):
        n = super().keyin()
        self.tozala()                   # keyin
        return n

    def orasida(self):
        self.boshla()
        n = super().orasida()
        self.tugat()
        return n

class A: pass
class B(A): pass

b = B()

isinstance(b, B)                # True
isinstance(b, A)                # True   ✅ meros hisobga olinadi
isinstance(b, object)           # True
type(b) is A                    # False  ⚠️ aniq tur

issubclass(B, A)                # True
issubclass(A, B)                # False
issubclass(B, B)                # True   ⚠️ o'ziga ham True
issubclass(B, object)           # True

isinstance(x, (int, float))     # ✅ ikkalasidan biri
isinstance(x, int | float)      # ✅ 3.10+

# ⚠️ Tur bo'yicha shoxlanish — polimorfizm buzilgan
def yuza(shakl):
    if isinstance(shakl, Doira):
        return 3.14 * shakl.r ** 2
    elif isinstance(shakl, Kvadrat):
        return shakl.a ** 2

# ✅ Polimorfizm
def yuza(shakl):
    return shakl.yuza()

# ✅ 1. Turli turlarni qabul qilish
def f(x: int | str):
    if isinstance(x, str):
        x = int(x)

# ✅ 2. Chegarada tekshirish
def __eq__(self, boshqa):
    if not isinstance(boshqa, Nuqta):
        return NotImplemented

# ✅ 3. Rekursiv tuzilmalar
def tekis(x):
    if isinstance(x, (list, tuple)):
        return [b for a in x for b in tekis(a)]
    return [x]

class Ota:
    SINF_ATR = "ota"

    def __init__(self):
        self.nusxa_atr = "ota"

    def metod(self): ...

    @property
    def xususiyat(self): return 1

    @classmethod
    def sinf_metod(cls): ...

    @staticmethod
    def statik(): ...


class Bola(Ota):
    pass

class Bola(Ota):
    def __init__(self):
        self.oziniki = 1                # ⚠️ nusxa_atr yo'q!

Bola().nusxa_atr                        # AttributeError

class Royxat:
    def __init__(self): self._el = []

    def qosh(self, x):
        self._el.append(x)

    def kop_qosh(self, xs):
        for x in xs:
            self.qosh(x)                # ⚠️ o'z metodini chaqiradi


class SanovchiRoyxat(Royxat):
    def __init__(self):
        super().__init__()
        self.soni = 0

    def qosh(self, x):
        self.soni += 1
        super().qosh(x)

    def kop_qosh(self, xs):
        self.soni += len(xs)            # ⚠️
        super().kop_qosh(xs)             # → qosh() ni chaqiradi → yana sanaydi


s = SanovchiRoyxat()
s.kop_qosh([1, 2, 3])
s.soni                                  # 6 ⚠️ 3 kutilgan edi

class Bola(Ota):
    def metod(self):            qayta aniqlash
        n = super().metod()     ota-sinf mantiqi
        return n + " qo'shimcha"

Bola.__bases__      (<class 'Ota'>,)
Bola.__mro__        (Bola, Ota, object)
Bola.__base__       <class 'Ota'>

"Bola — bu bir turdagi Ota"   (is-a)

✅ It — Hayvon
❌ Mashina — Dvigatel     → kompozitsiya (has-a)
❌ Stack — list           → kompozitsiya

Avlod ota-sinf O'RNIGA ishlashi kerak.

Buzilish belgilari:
  • Avlodda NotImplementedError
  • Avlod shartni qattiqlashtiradi
  • isinstance tekshiruvlari paydo bo'ladi
  • Avlod invariantni buzadi

isinstance(b, A)        ✅ meros bilan
issubclass(B, A)        sinflar uchun
type(b) is A            ⚠️ aniq tur
issubclass(B, B)        True — o'ziga ham

Chuqurlik ≤ 2-3 daraja
Ota-sinf shartnomasini buzmang
Kod qayta ishlatish ≠ meros sababi
Ota-sinf ichki chaqiruvlarini hujjatlang

"""Merosning barcha asosiy jihatlari."""

print("=== 1. Nima meros olinadi ===\n")


class Ota:
    SINF_ATR = "ota-sinf-atributi"
    _ICHKI = "ota-ichki"

    def __init__(self, x):
        self.nusxa_atr = x

    def metod(self):
        return "ota.metod"

    @property
    def xususiyat(self):
        return "ota.xususiyat"

    @classmethod
    def sinf_metod(cls):
        return f"sinf_metod, cls={cls.__name__}"

    @staticmethod
    def statik():
        return "statik"

    def __repr__(self):
        return f"{type(self).__name__}({self.nusxa_atr!r})"


class Bola(Ota):
    pass                                    # hech narsa qo'shmadi


b = Bola("qiymat")

print(f"  Bola hech narsa qo'shmadi, lekin:")
TEKSHIRUV = [
    ("b.SINF_ATR",      lambda: b.SINF_ATR),
    ("b._ICHKI",        lambda: b._ICHKI),
    ("b.nusxa_atr",     lambda: b.nusxa_atr),
    ("b.metod()",       lambda: b.metod()),
    ("b.xususiyat",     lambda: b.xususiyat),
    ("b.sinf_metod()",  lambda: b.sinf_metod()),
    ("b.statik()",      lambda: b.statik()),
    ("repr(b)",         lambda: repr(b)),
]
for kod, f in TEKSHIRUV:
    print(f"    {kod:<20} → {f()!r}")

print(f"\n  Bola.__dict__ da o'zining nechta atributi bor: "
      f"{len([n for n in Bola.__dict__ if not n.startswith('__')])}")
print(f"  Lekin dir(b) da: {len([n for n in dir(b) if not n.startswith('__')])} ta")


print("\n=== 2. Qayta aniqlash va kengaytirish ===\n")


class Asos:
    def almashtiriladi(self):
        return "asos"

    def kengaytiriladi(self):
        return "asos"

    def oldin_keyin(self):
        return "asos-mantiq"


class Avlod(Asos):
    def almashtiriladi(self):
        return "avlod"                              # ota-sinf ISHLATILMAYDI

    def kengaytiriladi(self):
        return super().kengaytiriladi() + " + avlod"    # ⭐ ishlatiladi

    def oldin_keyin(self):
        return f"[oldin] {super().oldin_keyin()} [keyin]"


a, av = Asos(), Avlod()

print(f"  {'Metod':<20} {'Asos':<20} {'Avlod'}")
print("  " + "─" * 62)
for m in ["almashtiriladi", "kengaytiriladi", "oldin_keyin"]:
    print(f"  {m:<20} {getattr(a, m)()!r:<20} {getattr(av, m)()!r}")


print("\n=== ⚠️ 3. __init__ va meros ===\n")


class OtaInit:
    def __init__(self, a):
        self.a = a
        self.tayyorlangan = True


class BolaYomon(OtaInit):
    def __init__(self, a, b):
        self.b = b                          # ⚠️ super() yo'q


class BolaYaxshi(OtaInit):
    def __init__(self, a, b):
        super().__init__(a)                 # ✅
        self.b = b


for Sinf in (BolaYomon, BolaYaxshi):
    obj = Sinf(1, 2)
    bor = sorted(obj.__dict__)
    try:
        _ = obj.a
        natija = f"✅ obj.a = {obj.a}"
    except AttributeError as e:
        natija = f"❌ AttributeError: {e}"
    print(f"  {Sinf.__name__:<14} __dict__={bor}")
    print(f"  {'':<14} {natija}")

print(f"""
  ⭐ Avlodda __init__ aniqlansa, ota-sinfniki AVTOMATIK
     chaqirilmaydi. super().__init__(...) yozish SHART.

  ⚠️ Bu — merosdagi eng ko'p uchraydigan xato.
""")


print("=== 4. isinstance va issubclass ===\n")


class Hayvon: pass
class Sutemizuvchi(Hayvon): pass
class It(Sutemizuvchi): pass
class Mushuk(Sutemizuvchi): pass
class Qush(Hayvon): pass


it = It()

print(f"  MRO: {' → '.join(c.__name__ for c in It.__mro__)}\n")

print(f"  {'Ifoda':<34} {'Natija'}")
print("  " + "─" * 46)
IFODALAR = [
    ("isinstance(it, It)",              isinstance(it, It)),
    ("isinstance(it, Sutemizuvchi)",    isinstance(it, Sutemizuvchi)),
    ("isinstance(it, Hayvon)",          isinstance(it, Hayvon)),
    ("isinstance(it, object)",          isinstance(it, object)),
    ("isinstance(it, Mushuk)",          isinstance(it, Mushuk)),
    ("type(it) is It",                  type(it) is It),
    ("type(it) is Hayvon",              type(it) is Hayvon),
    ("issubclass(It, Hayvon)",          issubclass(It, Hayvon)),
    ("issubclass(Hayvon, It)",          issubclass(Hayvon, It)),
    ("issubclass(It, It)",              issubclass(It, It)),
    ("isinstance(it, (Qush, It))",      isinstance(it, (Qush, It))),
]
for kod, natija in IFODALAR:
    belgi = "✅" if natija else "  "
    print(f"  {kod:<34} {natija!s:<8} {belgi}")

print(f"""
  ⚠️ issubclass(It, It) = True — sinf O'ZINING avlodi hisoblanadi.
     Bu matematik kelishuv (refleksivlik).
""")


print("=== ⚠️ 5. isinstance bilan shoxlanish — antipattern ===\n")

import math


class Shakl: pass
class Doira(Shakl):
    def __init__(self, r): self.r = r
class Kvadrat(Shakl):
    def __init__(self, a): self.a = a
class Uchburchak(Shakl):
    def __init__(self, a, h): self.a, self.h = a, h


def yuza_yomon(s):
    """⚠️ Har yangi shakl uchun BU FUNKSIYANI o'zgartirish kerak."""
    if isinstance(s, Doira):
        return math.pi * s.r ** 2
    elif isinstance(s, Kvadrat):
        return s.a ** 2
    elif isinstance(s, Uchburchak):
        return s.a * s.h / 2
    raise TypeError(f"Noma'lum shakl: {type(s).__name__}")


class ShaklYaxshi:
    def yuza(self): raise NotImplementedError

class DoiraY(ShaklYaxshi):
    def __init__(self, r): self.r = r
    def yuza(self): return math.pi * self.r ** 2

class KvadratY(ShaklYaxshi):
    def __init__(self, a): self.a = a
    def yuza(self): return self.a ** 2

class UchburchakY(ShaklYaxshi):
    def __init__(self, a, h): self.a, self.h = a, h
    def yuza(self): return self.a * self.h / 2


print(f"  ⚠️ isinstance bilan:")
for s in [Doira(3), Kvadrat(4), Uchburchak(6, 5)]:
    print(f"    {type(s).__name__:<12} {yuza_yomon(s):>8.2f}")

print(f"\n  ✅ Polimorfizm bilan:")
for s in [DoiraY(3), KvadratY(4), UchburchakY(6, 5)]:
    print(f"    {type(s).__name__:<12} {s.yuza():>8.2f}")

print(f"""
  ⭐ YANGI SHAKL QO'SHISH:

     ⚠️ isinstance:  yuza_yomon() ni O'ZGARTIRISH kerak
                     (va boshqa 10 ta shunday funksiyani ham)

     ✅ Polimorfizm: faqat yangi sinf yozasiz
                     Mavjud kod O'ZGARMAYDI

  Bu — "Ochiq/yopiq tamoyili" (Open/Closed Principle):
     Kengaytirish uchun OCHIQ, o'zgartirish uchun YOPIQ.
""")


print("=== 6. Meros zanjiri ===\n")


class A:
    def kim(self): return "A"
    def faqat_a(self): return "faqat A da"

class B(A):
    def kim(self): return "B"

class C(B):
    pass

class D(C):
    def kim(self): return "D"


print(f"  Ierarxiya:  A → B → C → D\n")
print(f"  {'Sinf':<8} {'MRO':<32} {'kim()':<8} {'kim manbai'}")
print("  " + "─" * 66)
for S in (A, B, C, D):
    mro = " → ".join(c.__name__ for c in S.__mro__)
    manba = next(c.__name__ for c in S.__mro__ if "kim" in c.__dict__)
    print(f"  {S.__name__:<8} {mro:<32} {S().kim():<8} {manba}")

print(f"\n  faqat_a() barcha sinflarda:")
for S in (A, B, C, D):
    print(f"    {S.__name__}().faqat_a() = {S().faqat_a()!r}")

print(f"""
  ⭐ Qidiruv MRO bo'yicha, birinchi topilgan g'olib.
     C da kim() yo'q → B dan olinadi.
""")

=== 1. Nima meros olinadi ===

  Bola hech narsa qo'shmadi, lekin:
    b.SINF_ATR           → 'ota-sinf-atributi'
    b.metod()            → 'ota.metod'
    b.sinf_metod()       → 'sinf_metod, cls=Bola'
    repr(b)              → "Bola('qiymat')"

  Bola.__dict__ da o'zining nechta atributi bor: 0
  Lekin dir(b) da: 7 ta

=== ⚠️ 3. __init__ va meros ===

  BolaYomon      __dict__=['b']
                 ❌ AttributeError: 'BolaYomon' object has no attribute 'a'
  BolaYaxshi     __dict__=['a', 'b', 'tayyorlangan']
                 ✅ obj.a = 1

=== 6. Meros zanjiri ===

  Sinf     MRO                              kim()    kim manbai
  ──────────────────────────────────────────────────────────────────
  A        A → object                       A        A
  B        B → A → object                   B        B
  C        C → B → A → object                B        B
  D        D → C → B → A → object            D        D

"""Merosni qachon ishlatish — va qachon ishlatmaslik."""

from dataclasses import dataclass
from abc import ABC, abstractmethod

print("=== ⚠️ 1. Klassik muammo: Kvadrat/Togriturtburchak ===\n")


class Togriturtburchak:
    """SHARTNOMA: en va boy MUSTAQIL o'zgaradi."""

    def __init__(self, en: float, boy: float):
        self._en, self._boy = en, boy

    @property
    def en(self): return self._en

    @en.setter
    def en(self, q): self._en = q

    @property
    def boy(self): return self._boy

    @boy.setter
    def boy(self, q): self._boy = q

    def yuza(self): return self._en * self._boy

    def __repr__(self):
        return f"{type(self).__name__}(en={self._en}, boy={self._boy})"


class Kvadrat(Togriturtburchak):
    """⚠️ SHARTNOMANI BUZADI: tomonlar bog'liq."""

    def __init__(self, tomon: float):
        super().__init__(tomon, tomon)

    @Togriturtburchak.en.setter
    def en(self, q):
        self._en = self._boy = q            # ⚠️ boy ham o'zgardi

    @Togriturtburchak.boy.setter
    def boy(self, q):
        self._en = self._boy = q            # ⚠️


def mijoz_kodi(t: Togriturtburchak) -> tuple[float, bool]:
    """Togriturtburchak SHARTNOMASIGA tayanadi."""
    t.en = 5
    t.boy = 4
    return t.yuza(), t.yuza() == 20


print(f"  Mijoz kodi: t.en=5; t.boy=4; kutiladi yuza==20\n")
for obj in [Togriturtburchak(1, 1), Kvadrat(1)]:
    yuza, togri = mijoz_kodi(obj)
    belgi = "✅" if togri else "❌ LSP BUZILDI"
    print(f"    {type(obj).__name__:<18} yuza={yuza:<6} {belgi}")

print(f"""
  ⭐ MUAMMO:
     Matematikada kvadrat — to'rtburchak.
     Lekin O'ZGARUVCHAN obyektlarda "is-a" — bu XATTI-HARAKAT
     haqida, shakl haqida emas.

     Togriturtburchak shartnomasi: "en va boy mustaqil".
     Kvadrat buni buzadi → LSP buzilishi.
""")


print("=== ✅ 2. Yechim A: o'zgarmas qilish ===\n")


@dataclass(frozen=True)
class TT:
    en: float
    boy: float

    @property
    def yuza(self): return self.en * self.boy

    def olcham(self, en=None, boy=None) -> "TT":
        """Yangi obyekt qaytaradi."""
        return TT(en if en is not None else self.en,
                  boy if boy is not None else self.boy)


@dataclass(frozen=True)
class Kv(TT):
    def __init__(self, tomon: float):
        super().__init__(tomon, tomon)

    def olcham(self, en=None, boy=None) -> TT:
        """⭐ TT qaytaradi — Kv emas (kvadrat bo'lmasligi mumkin)."""
        return TT(en if en is not None else self.en,
                  boy if boy is not None else self.boy)


t1 = TT(5, 4)
k1 = Kv(3)

print(f"  t1 = {t1}, yuza = {t1.yuza}")
print(f"  k1 = {k1}, yuza = {k1.yuza}")

t2 = t1.olcham(en=10)
k2 = k1.olcham(en=10)
print(f"\n  t1.olcham(en=10) = {t2}, yuza = {t2.yuza}")
print(f"  k1.olcham(en=10) = {k2}, yuza = {k2.yuza}   ✅ TT qaytdi")
print(f"\n  Asl obyektlar o'zgarmadi: t1={t1}, k1={k1}   ✅")

print(f"""
  ⭐ O'ZGARMASLIK LSP muammosini YO'Q QILADI:
     • Setter yo'q → shartnoma buzilmaydi
     • Har o'zgarish — yangi obyekt
     • Kvadrat o'lchami o'zgarsa — TT bo'ladi (to'g'ri!)
""")


print("=== ✅ 3. Yechim B: birodar sinflar ===\n")


class Shakl(ABC):
    """Umumiy shartnoma — faqat yuza va perimetr."""

    @abstractmethod
    def yuza(self) -> float: ...

    @abstractmethod
    def perimetr(self) -> float: ...

    def tavsif(self) -> str:
        return (f"{type(self).__name__}: yuza={self.yuza():.2f}, "
                f"perimetr={self.perimetr():.2f}")


@dataclass
class TogriturtburchakS(Shakl):
    en: float
    boy: float
    def yuza(self): return self.en * self.boy
    def perimetr(self): return 2 * (self.en + self.boy)


@dataclass
class KvadratS(Shakl):
    tomon: float
    def yuza(self): return self.tomon ** 2
    def perimetr(self): return 4 * self.tomon


@dataclass
class DoiraS(Shakl):
    r: float
    def yuza(self): return 3.14159 * self.r ** 2
    def perimetr(self): return 2 * 3.14159 * self.r


SHAKLLAR = [TogriturtburchakS(5, 4), KvadratS(3), DoiraS(2)]

for s in SHAKLLAR:
    print(f"  {s.tavsif()}")

print(f"\n  Jami yuza: {sum(s.yuza() for s in SHAKLLAR):.2f}")
print(f"  MRO: KvadratS → {' → '.join(c.__name__ for c in KvadratS.__mro__[1:])}")

print(f"""
  ⭐ KvadratS va TogriturtburchakS — BIRODAR, avlod emas.
     Ular umumiy SHARTNOMANI (Shakl) bajaradi,
     lekin bir-birining o'rniga ishlashi SHART EMAS.
""")


print("=== ⚠️ 4. Boshqa LSP buzilishlari ===\n")

print("""  A) Avlod xatolik tashlaydi:

     class Qush:
         def uch(self): return "uchdi"

     class Pingvin(Qush):
         def uch(self):
             raise NotImplementedError("Pingvin ucholmaydi")  ⚠️

     def sayohat(q: Qush):
         q.uch()                    # ⚠️ Pingvin bilan buziladi

     ✅ YECHIM:
        class Qush: ...
        class UchuvchiQush(Qush):
            def uch(self): ...
        class Pingvin(Qush): ...    # uch() umuman yo'q


  B) Avlod shartni QATTIQLASHTIRADI:

     class Ombor:
         def saqla(self, kalit: str, qiymat): ...

     class ChegaralanganOmbor(Ombor):
         def saqla(self, kalit: str, qiymat):
             if len(kalit) > 10:    ⚠️ Ota qabul qilardi
                 raise ValueError(...)

     ⭐ QOIDA: avlod KO'PROQ qabul qilishi, KAMROQ emas.
               (kirish — bo'shashadi, chiqish — qattiqlashadi)


  C) Avlod BOSHQA turni qaytaradi:

     class Ota:
         def olish(self) -> list: return []

     class Bola(Ota):
         def olish(self) -> dict: return {}    ⚠️

     ⭐ QOIDA: qaytarish turi TORAYISHI mumkin:
        list → list  ✅
        object → str ✅ (aniqroq)
        list → dict  ❌ (boshqa)


  D) Avlod invariantni buzadi:

     class Hisob:
         # INVARIANT: balans >= 0
         def yech(self, n):
             if n > self._balans: raise ValueError(...)

     class KreditHisob(Hisob):
         def yech(self, n):
             self._balans -= n      ⚠️ manfiy bo'lishi mumkin

     ✅ Umumiy ota-sinf yarating yoki invariantni
        boshidan kengroq qiling.
""")


print("=== 5. LSP tekshiruvchi test ===\n")


def lsp_test(Ota, Bola, sinovlar):
    """Bola Ota o'rniga ishlaydimi — tekshiradi."""
    natijalar = []
    for nom, tayyorla, amal, kutilgan in sinovlar:
        qatorlar = []
        for S in (Ota, Bola):
            try:
                obj = tayyorla(S)
                natija = amal(obj)
                qatorlar.append(("✅" if natija == kutilgan(obj)
                                 else f"❌ {natija}"))
            except Exception as e:
                qatorlar.append(f"❌ {type(e).__name__}")
        natijalar.append((nom, *qatorlar))
    return natijalar


SINOVLAR = [
    ("en/boy mustaqil",
     lambda S: S(1) if S is Kvadrat else S(1, 1),
     lambda o: (setattr(o, "en", 5), setattr(o, "boy", 4), o.yuza())[-1],
     lambda o: 20),
    ("yuza musbat",
     lambda S: S(3) if S is Kvadrat else S(3, 3),
     lambda o: o.yuza() > 0,
     lambda o: True),
    ("repr ishlaydi",
     lambda S: S(2) if S is Kvadrat else S(2, 2),
     lambda o: isinstance(repr(o), str),
     lambda o: True),
]

print(f"  {'Sinov':<22} {'Togriturtburchak':<20} {'Kvadrat'}")
print("  " + "─" * 56)
for nom, r1, r2 in lsp_test(Togriturtburchak, Kvadrat, SINOVLAR):
    print(f"  {nom:<22} {r1:<20} {r2}")

print(f"""
  ⭐ AMALIY QOIDA:
     Ota-sinf uchun yozilgan HAR TEST avlod bilan ham o'tishi kerak.

     Agar o'tmasa — bu meros EMAS.
     Testlarni parametrlashtiring:

     @pytest.mark.parametrize("Sinf", [Ota, Bola1, Bola2])
     def test_shartnoma(Sinf): ...
""")

=== ⚠️ 1. Klassik muammo: Kvadrat/Togriturtburchak ===

  Mijoz kodi: t.en=5; t.boy=4; kutiladi yuza==20

    Togriturtburchak   yuza=20     ✅
    Kvadrat            yuza=16     ❌ LSP BUZILDI

=== ✅ 2. Yechim A: o'zgarmas qilish ===

  t1.olcham(en=10) = TT(en=10, boy=4), yuza = 40
  k1.olcham(en=10) = TT(en=10, boy=3), yuza = 30   ✅ TT qaytdi

  Asl obyektlar o'zgarmadi: t1=TT(en=5, boy=4), k1=Kv(en=3, boy=3)   ✅

=== 5. LSP tekshiruvchi test ===

  Sinov                  Togriturtburchak     Kvadrat
  ────────────────────────────────────────────────────────
  en/boy mustaqil        ✅                   ❌ 16
  yuza musbat            ✅                   ✅
  repr ishlaydi          ✅                   ✅

"""Ota-sinf o'zgarishi avlodlarni qanday buzadi."""

print("=== ⚠️ 1. Klassik mo'rt asosiy sinf ===\n")


class RoyxatV1:
    """1-versiya."""

    def __init__(self):
        self._el = []

    def qosh(self, x):
        self._el.append(x)

    def kop_qosh(self, xs):
        for x in xs:
            self.qosh(x)                    # ⚠️ o'z metodini chaqiradi

    def __len__(self):
        return len(self._el)


class Sanovchi(RoyxatV1):
    """Qo'shilganlarni sanaydi."""

    def __init__(self):
        super().__init__()
        self.soni = 0

    def qosh(self, x):
        self.soni += 1
        super().qosh(x)

    def kop_qosh(self, xs):
        self.soni += len(xs)                # ⚠️
        super().kop_qosh(xs)


s = Sanovchi()
s.qosh("a")
print(f"  s.qosh('a')       → soni={s.soni}, len={len(s)}   ✅")

s2 = Sanovchi()
s2.kop_qosh(["a", "b", "c"])
print(f"  s2.kop_qosh(3 ta) → soni={s2.soni}, len={len(s2)}   "
      f"⚠️ soni 3 bo'lishi kerak edi")

print(f"""
  ⭐ SABAB:
     kop_qosh() → super().kop_qosh() → tsiklda self.qosh()
     → Sanovchi.qosh() → soni yana oshadi

     Ya'ni har element IKKI MARTA sanaladi.
""")


print("=== ⚠️ 2. Ota-sinf o'zgarsa ===\n")


class RoyxatV2:
    """2-versiya: kop_qosh optimallashtirildi."""

    def __init__(self):
        self._el = []

    def qosh(self, x):
        self._el.append(x)

    def kop_qosh(self, xs):
        self._el.extend(xs)                 # ⭐ endi qosh() chaqirilmaydi

    def __len__(self):
        return len(self._el)


class SanovchiV2(RoyxatV2):
    """AYNAN o'sha kod."""

    def __init__(self):
        super().__init__()
        self.soni = 0

    def qosh(self, x):
        self.soni += 1
        super().qosh(x)

    def kop_qosh(self, xs):
        self.soni += len(xs)
        super().kop_qosh(xs)


s3 = SanovchiV2()
s3.kop_qosh(["a", "b", "c"])
print(f"  V2 bilan: soni={s3.soni}, len={len(s3)}   ✅ endi to'g'ri")

print(f"""
  ⚠️ MUAMMO: Sanovchi kodi O'ZGARMADI, lekin xatti-harakati
     ota-sinfning ICHKI AMALGA OSHIRILISHIGA qarab o'zgardi.

     V1: soni = 6  ❌
     V2: soni = 3  ✅

  Bu — MO'RT ASOSIY SINF (fragile base class) muammosi.
""")


print("=== ✅ 3. Yechim A: ichki chaqiruvlarni yashirish ===\n")


class RoyxatXavfsiz:
    """Ichki amalga oshirish XUSUSIY metodlar orqali."""

    def __init__(self):
        self._el = []

    def qosh(self, x):
        self.__qosh(x)                      # ⭐ xususiy

    def kop_qosh(self, xs):
        for x in xs:
            self.__qosh(x)                  # ⭐ avlod ushlab qololmaydi

    def __qosh(self, x):
        """Xususiy — nom buzilishi tufayli qayta aniqlab bo'lmaydi."""
        self._el.append(x)

    def __len__(self):
        return len(self._el)


class SanovchiXavfsiz(RoyxatXavfsiz):
    def __init__(self):
        super().__init__()
        self.soni = 0

    def qosh(self, x):
        self.soni += 1
        super().qosh(x)

    def kop_qosh(self, xs):
        self.soni += len(xs)
        super().kop_qosh(xs)


s4 = SanovchiXavfsiz()
s4.qosh("a")
s4.kop_qosh(["b", "c", "d"])
print(f"  qosh(1) + kop_qosh(3) → soni={s4.soni}, len={len(s4)}   ✅")

print(f"\n  Xususiy metod nomi: "
      f"{[n for n in RoyxatXavfsiz.__dict__ if 'qosh' in n]}")

print(f"""
  ⭐ __qosh → _RoyxatXavfsiz__qosh (nom buzilishi, 8.10-dars)
     Avlod uni tasodifan qayta aniqlay olmaydi.

  ⚠️ Lekin bu ATAYLAB kengaytirishni ham to'sadi.
""")


print("=== ✅ 4. Yechim B: kompozitsiya ===\n")


class SanovchiKompozitsiya:
    """Merosdan voz kechildi — ichida ro'yxat BOR."""

    def __init__(self):
        self._royxat = RoyxatV1()           # ⭐ ichida
        self.soni = 0

    def qosh(self, x):
        self.soni += 1
        self._royxat.qosh(x)

    def kop_qosh(self, xs):
        self.soni += len(xs)
        for x in xs:
            self._royxat.qosh(x)            # ⭐ ANIQ nima chaqirilishini bilamiz

    def __len__(self):
        return len(self._royxat)


s5 = SanovchiKompozitsiya()
s5.qosh("a")
s5.kop_qosh(["b", "c", "d"])
print(f"  qosh(1) + kop_qosh(3) → soni={s5.soni}, len={len(s5)}   ✅")

print(f"""
  ⭐ KOMPOZITSIYA AFZALLIKLARI:
     ✅ Ota-sinf ichki o'zgarishlariga BOG'LIQ EMAS
     ✅ Faqat OMMAVIY API ishlatiladi
     ✅ Ro'yxatni boshqa amalga oshirish bilan almashtirish oson
     ✅ Nima chaqirilishi ANIQ ko'rinadi

  ⚠️ Kamchiligi:
     • isinstance(s5, RoyxatV1) → False
     • Har metodni qo'lda uzatish kerak
""")


print("=== ✅ 5. Yechim C: shablon metod naqshi ===\n")


class RoyxatShablon:
    """Kengaytirish NUQTALARI aniq belgilangan."""

    def __init__(self):
        self._el = []

    # ── Ommaviy API (qayta aniqlanmasin) ──

    def qosh(self, x):
        self._qoshishdan_oldin(x)           # ⭐ ilgak
        self._el.append(x)
        self._qoshilgandan_keyin(x)         # ⭐ ilgak

    def kop_qosh(self, xs):
        xs = list(xs)
        self._kop_qoshishdan_oldin(xs)      # ⭐ ilgak
        for x in xs:
            self._qoshishdan_oldin(x)
            self._el.append(x)
            self._qoshilgandan_keyin(x)

    # ── Kengaytirish nuqtalari (avlodlar uchun) ──

    def _qoshishdan_oldin(self, x): pass
    def _qoshilgandan_keyin(self, x): pass
    def _kop_qoshishdan_oldin(self, xs): pass

    def __len__(self):
        return len(self._el)


class SanovchiShablon(RoyxatShablon):
    def __init__(self):
        super().__init__()
        self.soni = 0
        self.jurnal = []

    def _qoshilgandan_keyin(self, x):       # ⭐ faqat ilgak
        self.soni += 1
        self.jurnal.append(f"+{x}")


class TekshiruvchiShablon(RoyxatShablon):
    def _qoshishdan_oldin(self, x):
        if not isinstance(x, str):
            raise TypeError(f"Faqat satr: {type(x).__name__}")


s6 = SanovchiShablon()
s6.qosh("a")
s6.kop_qosh(["b", "c", "d"])
print(f"  SanovchiShablon:")
print(f"    soni={s6.soni}, len={len(s6)}   ✅")
print(f"    jurnal={s6.jurnal}")

t6 = TekshiruvchiShablon()
t6.qosh("ok")
try:
    t6.qosh(42)
except TypeError as e:
    print(f"\n  TekshiruvchiShablon:")
    print(f"    t6.qosh(42) → ✅ TypeError: {e}")

print(f"""
  ⭐ SHABLON METOD NAQSHI:
     • Ota-sinf ALGORITMNI boshqaradi
     • Avlodlar faqat ILGAKLARNI (hook) to'ldiradi
     • Ichki chaqiruv tartibi ota-sinf ichida qoladi

  Bu — merosning ENG XAVFSIZ shakli.
""")


print("=== 6. Solishtirish ===\n")

print("""
  ┌────────────────────┬──────────┬──────────────┬────────────┐
  │ Yondashuv          │ Mo'rtlik │ Moslashuvchi │ Kod hajmi  │
  ├────────────────────┼──────────┼──────────────┼────────────┤
  │ Oddiy meros        │ ⚠️ yuqori│ ✅ yuqori    │ ✅ kam     │
  │ Xususiy metodlar   │ ✅ past  │ ⚠️ past      │ ✅ kam     │
  │ Kompozitsiya       │ ✅ yo'q  │ ✅ yuqori    │ ⚠️ ko'p    │
  │ Shablon metod      │ ✅ past  │ ✅ o'rta     │ ⚠️ o'rta   │
  └────────────────────┴──────────┴──────────────┴────────────┘

  ⭐ TANLASH:
     Kutubxona yozyapsizmi (boshqalar meros oladi)?
       → Shablon metod + ilgaklar, ichki chaqiruvlarni hujjatlang

     Ichki kodmi (siz nazorat qilasiz)?
       → Oddiy meros yetadi

     Uchinchi tomon sinfini kengaytiryapsizmi?
       → Kompozitsiya (ular ichini istalgan vaqt o'zgartiradi)
""")

=== ⚠️ 1. Klassik mo'rt asosiy sinf ===

  s.qosh('a')       → soni=1, len=1   ✅
  s2.kop_qosh(3 ta) → soni=6, len=3   ⚠️ soni 3 bo'lishi kerak edi

=== ⚠️ 2. Ota-sinf o'zgarsa ===

  V2 bilan: soni=3, len=3   ✅ endi to'g'ri

  ⚠️ MUAMMO: Sanovchi kodi O'ZGARMADI, lekin xatti-harakati
     ota-sinfning ICHKI AMALGA OSHIRILISHIGA qarab o'zgardi.

=== ✅ 5. Yechim C: shablon metod naqshi ===

  SanovchiShablon:
    soni=4, len=4   ✅
    jurnal=['+a', '+b', '+c', '+d']

  TekshiruvchiShablon:
    t6.qosh(42) → ✅ TypeError: Faqat satr: int

"""To'g'ri loyihalangan meros ierarxiyasi."""

from __future__ import annotations

import html
import json
import re
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from datetime import date

print("=== HUJJAT TIZIMI ===\n")


class Hujjat(ABC):
    """Barcha hujjatlar uchun umumiy shartnoma.

    SHARTNOMA:
      • matn — hujjat mazmuni (satr)
      • render() — chiqish formatiga o'giradi
      • KENGAYTMA, MIME — sinf darajasida

    AVLODLAR: render() ni MAJBURIY amalga oshiradi.
    Boshqa metodlar ixtiyoriy kengaytiriladi.
    """

    KENGAYTMA: str = ".txt"
    MIME: str = "text/plain"
    MAKS_HAJM = 1_000_000

    def __init__(self, nom: str, matn: str = "", muallif: str = ""):
        if not nom.strip():
            raise ValueError("Nom bo'sh bo'lmasin")
        if len(matn) > self.MAKS_HAJM:
            raise ValueError(f"Juda katta: {len(matn)} > {self.MAKS_HAJM}")

        self.nom = nom.strip()
        self.matn = matn
        self.muallif = muallif
        self.yaratilgan = date.today()
        self._teglar: set[str] = set()

    # ── Abstrakt (avlodlar amalga oshiradi) ──

    @abstractmethod
    def render(self) -> str:
        """Hujjatni chiqish formatiga o'giradi."""

    # ── Umumiy (barcha avlodlar uchun) ──

    @property
    def fayl_nomi(self) -> str:
        xavfsiz = re.sub(r"[^\w\s-]", "", self.nom).strip()
        xavfsiz = re.sub(r"[\s]+", "-", xavfsiz).lower()
        return f"{xavfsiz}{self.KENGAYTMA}"

    @property
    def teglar(self) -> tuple[str, ...]:
        return tuple(sorted(self._teglar))

    def teg_qosh(self, *teglar: str) -> None:
        self._teglar.update(t.strip().lower() for t in teglar if t.strip())

    def statistika(self) -> dict[str, int]:
        return {
            "belgilar": len(self.matn),
            "sozlar": len(self.matn.split()),
            "qatorlar": self.matn.count("\n") + 1 if self.matn else 0,
        }

    # ── Kengaytirish nuqtalari (ilgaklar) ──

    def _sarlavha(self) -> str:
        """Avlodlar qayta aniqlashi mumkin."""
        return self.nom

    def _ostki_matn(self) -> str:
        """Avlodlar qayta aniqlashi mumkin."""
        return f"Muallif: {self.muallif}" if self.muallif else ""

    def __repr__(self) -> str:
        return (f"{type(self).__name__}({self.nom!r}, "
                f"{len(self.matn)} belgi)")

    def __str__(self) -> str:
        return f"{self.fayl_nomi} ({self.MIME})"


class MatnHujjat(Hujjat):
    """Oddiy matn."""

    KENGAYTMA = ".txt"
    MIME = "text/plain"

    def render(self) -> str:
        qismlar = [self._sarlavha(), "=" * len(self._sarlavha()), "",
                   self.matn]
        ostki = self._ostki_matn()
        if ostki:
            qismlar += ["", "-" * 40, ostki]
        return "\n".join(qismlar)


class MarkdownHujjat(Hujjat):
    """Markdown formati."""

    KENGAYTMA = ".md"
    MIME = "text/markdown"

    def render(self) -> str:
        qismlar = [f"# {self._sarlavha()}", ""]
        if self._teglar:
            qismlar.append(" ".join(f"`{t}`" for t in self.teglar))
            qismlar.append("")
        qismlar.append(self.matn)
        ostki = self._ostki_matn()
        if ostki:
            qismlar += ["", "---", f"*{ostki}*"]
        return "\n".join(qismlar)

    def _ostki_matn(self) -> str:
        """⭐ Kengaytirish — sana ham qo'shildi."""
        asos = super()._ostki_matn()
        sana = f"Sana: {self.yaratilgan:%d.%m.%Y}"
        return f"{asos} · {sana}" if asos else sana


class HtmlHujjat(Hujjat):
    """HTML formati."""

    KENGAYTMA = ".html"
    MIME = "text/html"
    SHABLON = ("<!DOCTYPE html>\n<html lang=\"uz\">\n<head>\n"
               "  <meta charset=\"utf-8\">\n  <title>{sarlavha}</title>\n"
               "</head>\n<body>\n{tana}\n</body>\n</html>")

    def render(self) -> str:
        sarlavha = html.escape(self._sarlavha())
        paragraflar = "\n".join(
            f"  <p>{html.escape(q)}</p>"
            for q in self.matn.split("\n\n") if q.strip()
        )
        tana = f"  <h1>{sarlavha}</h1>\n{paragraflar}"
        ostki = self._ostki_matn()
        if ostki:
            tana += f"\n  <footer>{html.escape(ostki)}</footer>"
        return self.SHABLON.format(sarlavha=sarlavha, tana=tana)


class JsonHujjat(Hujjat):
    """Strukturalangan ma'lumot."""

    KENGAYTMA = ".json"
    MIME = "application/json"

    def render(self) -> str:
        return json.dumps({
            "nom": self.nom,
            "muallif": self.muallif,
            "sana": self.yaratilgan.isoformat(),
            "teglar": list(self.teglar),
            "matn": self.matn,
            "statistika": self.statistika(),
        }, ensure_ascii=False, indent=2)


class MaqolaHujjat(MarkdownHujjat):
    """⭐ Ikkinchi daraja — Markdown ni kengaytiradi."""

    KENGAYTMA = ".article.md"

    def __init__(self, nom, matn="", muallif="", *, qisqacha: str = ""):
        super().__init__(nom, matn, muallif)
        self.qisqacha = qisqacha

    def render(self) -> str:
        """⭐ Ota-sinf natijasiga qo'shimcha."""
        asos = super().render()
        if self.qisqacha:
            qatorlar = asos.split("\n")
            qatorlar.insert(2, f"> {self.qisqacha}\n")
            return "\n".join(qatorlar)
        return asos


print("1. Ierarxiya:\n")

TURLAR = [MatnHujjat, MarkdownHujjat, HtmlHujjat, JsonHujjat, MaqolaHujjat]

print(f"  {'Sinf':<18} {'Kengaytma':<14} {'MIME':<22} {'Chuqurlik'}")
print("  " + "─" * 66)
for S in TURLAR:
    chuqurlik = len(S.__mro__) - 2          # object va ABC ni hisobga olmaymiz
    print(f"  {S.__name__:<18} {S.KENGAYTMA:<14} {S.MIME:<22} {chuqurlik}")

print(f"\n  MaqolaHujjat MRO:")
print(f"    {' → '.join(c.__name__ for c in MaqolaHujjat.__mro__)}")


print("\n\n2. Bir mazmun — turli render:\n")

MATN = ("Python — kuchli dasturlash tili.\n\n"
        "U o'rganish oson va imkoniyatlari keng.")

hujjatlar = []
for S in TURLAR:
    kw = {"qisqacha": "Python haqida qisqacha"} if S is MaqolaHujjat else {}
    h = S("Python haqida", MATN, "Aziz Karimov", **kw)
    h.teg_qosh("python", "dasturlash", "Darslik")
    hujjatlar.append(h)

for h in hujjatlar:
    print(f"  ┌─ {type(h).__name__} → {h.fayl_nomi}")
    natija = h.render()
    for q in natija.split("\n")[:6]:
        print(f"  │ {q[:64]}")
    qolgan = len(natija.split("\n")) - 6
    if qolgan > 0:
        print(f"  │ ... yana {qolgan} qator")
    print(f"  └{'─' * 60}\n")


print("3. ⭐ Polimorfizm:\n")


def hammasini_saqla(hujjatlar: list[Hujjat]) -> dict[str, int]:
    """⭐ Aniq turni BILMAYDI — faqat Hujjat shartnomasiga tayanadi."""
    natija = {}
    for h in hujjatlar:
        natija[h.fayl_nomi] = len(h.render())
    return natija


for nom, hajm in hammasini_saqla(hujjatlar).items():
    print(f"  {nom:<34} {hajm:>6} belgi")

print(f"\n  Jami: {sum(hammasini_saqla(hujjatlar).values())} belgi")


print("\n\n4. Umumiy metodlar (bir marta yozilgan):\n")

h = hujjatlar[1]
print(f"  {type(h).__name__} uchun:")
print(f"    statistika()  = {h.statistika()}")
print(f"    teglar        = {h.teglar}")
print(f"    fayl_nomi     = {h.fayl_nomi}")
print(f"    str()         = {h}")
print(f"    repr()        = {h!r}")

print(f"\n  ⭐ Bularning hammasi Hujjat da BIR MARTA yozilgan.")


print("\n\n5. Kengaytirish nuqtasi (_ostki_matn):\n")

print(f"  {'Sinf':<18} {'_ostki_matn()'}")
print("  " + "─" * 62)
for h in hujjatlar:
    print(f"  {type(h).__name__:<18} {h._ostki_matn()!r}")

print(f"""
  ⭐ MarkdownHujjat._ostki_matn():
       super()._ostki_matn() + sana

     Bu — KENGAYTIRISH, almashtirish emas.
""")


print("=== 6. Shartnoma tekshiruvi ===\n")


def shartnoma_testi(Sinf: type[Hujjat]) -> list[tuple[str, bool, str]]:
    """⭐ Har avlod uchun BIR XIL testlar (LSP)."""
    natijalar = []
    kw = {"qisqacha": "test"} if Sinf is MaqolaHujjat else {}

    sinovlar = [
        ("render() satr qaytaradi",
         lambda: isinstance(Sinf("T", "matn", **kw).render(), str)),
        ("render() bo'sh emas",
         lambda: len(Sinf("T", "matn", **kw).render()) > 0),
        ("bo'sh matn ishlaydi",
         lambda: isinstance(Sinf("T", "", **kw).render(), str)),
        ("bo'sh nom xato beradi",
         lambda: _xato_beradi(lambda: Sinf("", "m", **kw), ValueError)),
        ("fayl_nomi kengaytma bilan",
         lambda: Sinf("T", **kw).fayl_nomi.endswith(Sinf.KENGAYTMA)),
        ("teg qo'shish ishlaydi",
         lambda: _teg_test(Sinf, kw)),
        ("statistika() to'g'ri",
         lambda: Sinf("T", "bir ikki", **kw).statistika()["sozlar"] == 2),
    ]

    for nom, f in sinovlar:
        try:
            ok = bool(f())
            natijalar.append((nom, ok, "" if ok else "False qaytdi"))
        except Exception as e:
            natijalar.append((nom, False, f"{type(e).__name__}: {e}"))
    return natijalar


def _xato_beradi(f, tur) -> bool:
    try:
        f()
        return False
    except tur:
        return True


def _teg_test(Sinf, kw) -> bool:
    h = Sinf("T", **kw)
    h.teg_qosh("A", "b", "  ")
    return h.teglar == ("a", "b")


print(f"  {'Sinov':<28} " + " ".join(f"{S.__name__[:7]:<8}" for S in TURLAR))
print("  " + "─" * 74)

barcha = {S.__name__: shartnoma_testi(S) for S in TURLAR}
sinov_nomlari = [n for n, _, _ in barcha[TURLAR[0].__name__]]

for i, nom in enumerate(sinov_nomlari):
    qatorlar = []
    for S in TURLAR:
        _, ok, _ = barcha[S.__name__][i]
        qatorlar.append(f"{'✅' if ok else '❌':<8}")
    print(f"  {nom:<28} " + " ".join(qatorlar))

jami = sum(1 for r in barcha.values() for _, ok, _ in r if ok)
kutilgan = len(TURLAR) * len(sinov_nomlari)
print(f"\n  Natija: {jami}/{kutilgan} test o'tdi")

print(f"""

  ⭐ BU IERARXIYA NEGA TO'G'RI:

     1. "is-a" haqiqiy: MarkdownHujjat — bu Hujjat ✅
     2. Chuqurlik ≤ 3 daraja
     3. Ota-sinf ABSTRAKT — o'zi ishlatilmaydi
     4. Shartnoma aniq: render() majburiy
     5. Kengaytirish nuqtalari belgilangan (_sarlavha, _ostki_matn)
     6. Har avlod ota-sinf O'RNIGA ishlaydi (LSP ✅)
     7. Umumiy kod bir marta yozilgan
     8. Yangi format qo'shish — mavjud kodni o'zgartirmaydi
""")

1. Ierarxiya:

  Sinf               Kengaytma      MIME                   Chuqurlik
  ──────────────────────────────────────────────────────────────────
  MatnHujjat         .txt           text/plain             2
  MarkdownHujjat     .md            text/markdown          2
  MaqolaHujjat       .article.md    text/markdown          3

  MaqolaHujjat MRO:
    MaqolaHujjat → MarkdownHujjat → Hujjat → ABC → object

3. ⭐ Polimorfizm:

  python-haqida.txt                     166 belgi
  python-haqida.md                      171 belgi
  python-haqida.html                    288 belgi

=== 6. Shartnoma tekshiruvi ===

  Sinov                        MatnHuj  Markdow  HtmlHuj  JsonHuj  Maqola
  ──────────────────────────────────────────────────────────────────────
  render() satr qaytaradi      ✅       ✅       ✅       ✅       ✅
  bo'sh nom xato beradi        ✅       ✅       ✅       ✅       ✅
  statistika() to'g'ri         ✅       ✅       ✅       ✅       ✅

  Natija: 35/35 test o'tdi

class B(A):
    def __init__(self, x, y):
        self.y = y                  # ⚠️
        super().__init__(x)         # ✅

class Mashina(Dvigatel): ...        # ❌
class Mashina:
    def __init__(self):
        self.dvigatel = Dvigatel()  # ✅

class Pingvin(Qush):
    def uch(self):
        raise NotImplementedError   # ⚠️ LSP buzilishi

if isinstance(s, Doira): ...        # ⚠️
return s.yuza()                     # ✅

class B(A):
    TEGLAR = A.TEGLAR
    TEGLAR.add("yangi")             # ⚠️ A niki ham o'zgardi
    TEGLAR = A.TEGLAR | {"yangi"}   # ✅

A → B → C → D → E → F               # ⚠️
A → B  +  kompozitsiya              # ✅

class Sozlama(dict): ...            # ⚠️ ko'p metod, kutilmagan xatti-harakat
class Sozlama(UserDict): ...        # ✅ collections.UserDict
class Sozlama:                      # ✅ kompozitsiya
    def __init__(self): self._d = {}

def kop_qosh(self, xs):
    self.soni += len(xs)
    super().kop_qosh(xs)            # ⚠️ ichida qosh() chaqirilishi mumkin

1.  class A:
        def f(self): return "A"
    class B(A): pass
    print(B().f())
2.  class A:
        def __init__(self): self.x = 1
    class B(A):
        def __init__(self): self.y = 2
    print(hasattr(B(), "x"))
3.  class A: x = 1
    class B(A): pass
    B.x = 2
    print(A.x, B.x)
4.  class A: pass
    class B(A): pass
    print(issubclass(B, A), issubclass(A, B), issubclass(B, B))
5.  class A:
        def f(self): return "A"
    class B(A):
        def f(self): return super().f() + "B"
    print(B().f())
6.  class A: pass
    print(A.__bases__, A.__mro__)
7.  class A:
        def f(self): return type(self).__name__
    class B(A): pass
    print(A().f(), B().f())
8.  class A:
        @classmethod
        def yarat(cls): return cls()
    class B(A): pass
    print(type(B.yarat()).__name__)
9.  class A: lst = []
    class B(A): pass
    B.lst.append(1)
    print(A.lst)
10. class A:
        def f(self): return self.g()
        def g(self): return "A.g"
    class B(A):
        def g(self): return "B.g"
    print(B().f())
11. class A: pass
    a = A()
    print(isinstance(a, object), issubclass(A, object))
12. class A:
        def __init__(self, x): self.x = x
    class B(A):
        def __init__(self, x, y):
            super().__init__(x)
            self.y = y
    print(sorted(B(1, 2).__dict__))

1.  Mashina va Dvigatel
2.  Talaba va Odam
3.  Stack va list
4.  AdminFoydalanuvchi va Foydalanuvchi
5.  Buyurtma va Mahsulot
6.  Kvadrat va Togriturtburchak (o'zgaruvchan)
7.  ValidationError va Exception
8.  Kesh va dict
9.  Uy va Xona
10. JsonHujjat va Hujjat