13.1-dars: Dinamik va statik turlash

def yuborish(oluvchilar, matn):
    for manzil in oluvchilar:
        jonat(manzil, matn)

def yuborish(oluvchilar: list[str], matn: str) -> int: ...

def yosh_qosh(yosh: int) -> int:
    return yosh + 1

yosh_qosh("yigirma")     # TypeError — lekin annotatsiya tufayli emas!

def komissiya(summa: float, foiz: float = 2.0) -> float: ...

komissiya.__annotations__     # {'summa': float, 'foiz': float, 'return': float}

import annotationlib
annotationlib.get_annotations(f)                                  # qiymatlar
annotationlib.get_annotations(f, format=annotationlib.Format.STRING)      # satrlar
annotationlib.get_annotations(f, format=annotationlib.Format.FORWARDREF)  # hal qilinmaganlari ForwardRef
typing.get_type_hints(f)                                          # satrlarni hal qiladi

def yoz(oqim):
    oqim.write("salom")      # "write metodi bo'lsa — yetarli"

def f(a: int, b: str = "x", *sonlar: float, **qolgan: object) -> bool: ...
maydon: dict[str, int] = {}
NOMLAR: list[str] = []

f.__annotations__            Klass.__annotations__       modul.__annotations__
typing.get_type_hints(f)     satrlarni hal qiladi
annotationlib.get_annotations(f, format=Format.STRING | FORWARDREF | VALUE)   # 3.14
inspect.signature(f)

ish vaqtida tekshirilmaydi        →  mypy / pyright
chegarada validatsiya             →  pydantic (13.8)
oldinga havola                    →  "Tugun" yoki 3.14 da to'g'ridan-to'g'ri
faqat tekshiruvchi uchun import   →  if TYPE_CHECKING:

"""Satrni ro'yxat o'rniga uzatish: jim xato; xato qayerda ko'rinadi; kuchli turlash; duck typing."""


def yuborish(oluvchilar: list[str], matn: str) -> int:
    """Har bir manzilga xabar yuboradi va yuborilganlar sonini qaytaradi."""
    yuborildi = 0
    for manzil in oluvchilar:
        if "@" not in manzil:
            navbat_xato.append(manzil)
        else:
            navbat_ok.append(manzil)
        yuborildi += 1
    return yuborildi


navbat_ok: list[str] = []
navbat_xato: list[str] = []

print("=== 1. Annotatsiya majburlamaydi ===")
print(f"  to'g'ri chaqiruv: {yuborish(['aziz@wisar.uz', 'dilnoza@wisar.uz'], 'salom')} ta xabar")
print(f"  navbatlar: ok={len(navbat_ok)}, xato={len(navbat_xato)}")

navbat_ok.clear()
navbat_xato.clear()
soni = yuborish("aziz@wisar.uz", "salom")          # ❌ list emas, str uzatildi
print(f"  yuborish('aziz@wisar.uz', ...) xato bermadi: {soni} ta 'xabar'")
print(f"  navbatlar: ok={len(navbat_ok)}, xato={len(navbat_xato)} — har harf alohida 'manzil' bo'ldi")
print(f"  birinchi uchtasi: {navbat_xato[:3]}")
print("  ⚠️ satr ham iteratsiyalanadi — shuning uchun xato jim o'tdi")

print("\n=== 2. Xato ancha keyin ko'rinadi ===")


def hisobot(manzillar: list[str]) -> str:
    domenlar = {m.split("@")[1] for m in manzillar}
    return f"{len(manzillar)} ta xabar, domenlar: {sorted(domenlar)}"


try:
    print(hisobot(navbat_xato))
except IndexError as xato:
    print(f"  IndexError: {xato}")
print("  ⭐ xato manbai — yuborish() chaqiruvi, lekin u hisobot bosqichida chiqdi")

print("\n=== 3. Python kuchli turlangan ===")
for ifoda, amal in [("1 + '2'", lambda: 1 + "2"), ("'2' * 3", lambda: "2" * 3), ("[1] + (2,)", lambda: [1] + (2,))]:
    try:
        print(f"  {ifoda:12} → {amal()!r}")
    except TypeError as xato:
        print(f"  {ifoda:12} → TypeError: {xato}")

print("\n=== 4. Duck typing ===")


class Fayl:
    def __init__(self):
        self.yozilgan = []

    def write(self, matn):
        self.yozilgan.append(matn)


class Tarmoq:
    def __init__(self):
        self.paketlar = []

    def write(self, matn):
        self.paketlar.append(matn.encode())


def jurnalga_yoz(oqim, xabar):
    """Tur emas, xulq muhim: write() bo'lsa yetarli."""
    oqim.write(xabar)


f, tarmoq = Fayl(), Tarmoq()
jurnalga_yoz(f, "boshlandi")
jurnalga_yoz(tarmoq, "boshlandi")
print(f"  ikki xil klass, bitta funksiya: {f.yozilgan}, {tarmoq.paketlar}")


class Sanoq:
    pass


try:
    jurnalga_yoz(Sanoq(), "salom")
except AttributeError as xato:
    print(f"  write yo'q bo'lsa: AttributeError: {xato}")

=== 1. Annotatsiya majburlamaydi ===
  to'g'ri chaqiruv: 2 ta xabar
  navbatlar: ok=2, xato=0
  yuborish('aziz@wisar.uz', ...) xato bermadi: 13 ta 'xabar'
  navbatlar: ok=1, xato=12 — har harf alohida 'manzil' bo'ldi
  birinchi uchtasi: ['a', 'z', 'i']
  ⚠️ satr ham iteratsiyalanadi — shuning uchun xato jim o'tdi

=== 2. Xato ancha keyin ko'rinadi ===
  IndexError: list index out of range
  ⭐ xato manbai — yuborish() chaqiruvi, lekin u hisobot bosqichida chiqdi

=== 3. Python kuchli turlangan ===
  1 + '2'      → TypeError: unsupported operand type(s) for +: 'int' and 'str'
  '2' * 3      → '222'
  [1] + (2,)   → TypeError: can only concatenate list (not "tuple") to list

=== 4. Duck typing ===
  ikki xil klass, bitta funksiya: ['boshlandi'], [b'boshlandi']
  write yo'q bo'lsa: AttributeError: 'Sanoq' object has no attribute 'write'

"""__annotations__; lokal o'zgaruvchi annotatsiyasi saqlanmaydi; oldinga havolalar; annotationlib formatlari 3.14-bob; get_type_hints; signature."""

import annotationlib
import inspect
import typing


def buyurtma(mijoz: str, soni: int = 1, *qoshimcha: float, yetkazish: "Manzil | None" = None) -> "Chek":
    jami: float = soni * 12_000.0        # lokal annotatsiya
    return jami


class Manzil:
    shahar: str
    kocha: str = "noma'lum"


class Chek:
    raqam: int
    manzil: "Manzil"


print("=== 1. Funksiya annotatsiyalari ===")
for nom, qiymat in buyurtma.__annotations__.items():
    print(f"  {nom:12} {qiymat!r}")
print(f"  lokal 'jami' annotatsiyasi saqlanganmi: {'jami' in buyurtma.__annotations__}")

print("\n=== 2. Klass va modul ===")
print(f"  Manzil.__annotations__: {Manzil.__annotations__}")
print(f"  sukut qiymat alohida: Manzil.kocha = {Manzil.kocha!r}, 'shahar' atributi bormi: {hasattr(Manzil, 'shahar')}")
print(f"  modul darajasidagi annotatsiyalar mavjud: {hasattr(__import__('sys').modules['__main__'], '__annotations__')}")

print("\n=== 3. 3.14: kechiktirilgan hisoblash ===")
print(f"  __annotate__ funksiyasi bor: {hasattr(buyurtma, '__annotate__')}")
satrlar = annotationlib.get_annotations(buyurtma, format=annotationlib.Format.STRING)
print(f"  STRING format: {satrlar}")
qiymatlar = annotationlib.get_annotations(buyurtma)
print(f"  VALUE format: mijoz={qiymatlar['mijoz'].__name__}, return={qiymatlar['return']!r}")

print("\n=== 4. Oldinga havolalar ===")
print(f"  Chek.__annotations__: {Chek.__annotations__}")
hal_qilingan = typing.get_type_hints(Chek)
print(f"  get_type_hints hal qildi: {{'raqam': {hal_qilingan['raqam'].__name__}, 'manzil': {hal_qilingan['manzil'].__name__}}}")


def noaniq(x: "HaliYoq") -> None:
    return None


try:
    typing.get_type_hints(noaniq)
except NameError as xato:
    print(f"  mavjud bo'lmagan turga havola: NameError: {xato}")
fr = annotationlib.get_annotations(noaniq, format=annotationlib.Format.FORWARDREF)
print(f"  FORWARDREF format xato bermaydi: {fr}")

print("\n=== 5. inspect.signature ===")
imzo = inspect.signature(buyurtma)
print(f"  imzo: {imzo}")
for nom, p in imzo.parameters.items():
    print(f"  {nom:12} turi: {p.annotation!r}, sukut: {p.default!r}, ko'rinishi: {p.kind.name}")

=== 1. Funksiya annotatsiyalari ===
  mijoz        <class 'str'>
  soni         <class 'int'>
  qoshimcha    <class 'float'>
  yetkazish    'Manzil | None'
  return       'Chek'
  lokal 'jami' annotatsiyasi saqlanganmi: False

=== 2. Klass va modul ===
  Manzil.__annotations__: {'shahar': <class 'str'>, 'kocha': <class 'str'>}
  sukut qiymat alohida: Manzil.kocha = "noma'lum", 'shahar' atributi bormi: False
  modul darajasidagi annotatsiyalar mavjud: True

=== 3. 3.14: kechiktirilgan hisoblash ===
  __annotate__ funksiyasi bor: True
  STRING format: {'mijoz': 'str', 'soni': 'int', 'qoshimcha': 'float', 'yetkazish': 'Manzil | None', 'return': 'Chek'}
  VALUE format: mijoz=str, return='Chek'

=== 4. Oldinga havolalar ===
  Chek.__annotations__: {'raqam': <class 'int'>, 'manzil': 'Manzil'}
  get_type_hints hal qildi: {'raqam': int, 'manzil': Manzil}
  mavjud bo'lmagan turga havola: NameError: name 'HaliYoq' is not defined
  FORWARDREF format xato bermaydi: {'x': 'HaliYoq', 'return': None}

=== 5. inspect.signature ===
  imzo: (mijoz: str, soni: int = 1, *qoshimcha: float, yetkazish: 'Manzil | None' = None) -> 'Chek'
  mijoz        turi: <class 'str'>, sukut: <class 'inspect._empty'>, ko'rinishi: POSITIONAL_OR_KEYWORD
  soni         turi: <class 'int'>, sukut: 1, ko'rinishi: POSITIONAL_OR_KEYWORD
  qoshimcha    turi: <class 'float'>, sukut: <class 'inspect._empty'>, ko'rinishi: VAR_POSITIONAL
  yetkazish    turi: 'Manzil | None', sukut: None, ko'rinishi: KEYWORD_ONLY

"""Annotatsiyaga qarab tekshiradigan dekorator; oddiy va umumiy turlar; narxi; chegarada tekshirish g'oyasi."""

import functools
import time
import typing


def turlarni_tekshir(funksiya):
    """Oddiy tekshiruvchi: faqat isinstance bilan tekshirib bo'ladigan turlar."""
    izohlar = typing.get_type_hints(funksiya)

    @functools.wraps(funksiya)
    def orov(*args, **kwargs):
        imzo = list(funksiya.__code__.co_varnames[:funksiya.__code__.co_argcount])
        for nom, qiymat in list(zip(imzo, args)) + list(kwargs.items()):
            kutilgan = izohlar.get(nom)
            if isinstance(kutilgan, type) and not isinstance(qiymat, kutilgan):
                raise TypeError(f"{funksiya.__name__}(): {nom} uchun {kutilgan.__name__} kutildi, {type(qiymat).__name__} keldi")
        natija = funksiya(*args, **kwargs)
        qaytish = izohlar.get("return")
        if isinstance(qaytish, type) and not isinstance(natija, qaytish):
            raise TypeError(f"{funksiya.__name__}(): {qaytish.__name__} qaytishi kerak edi, {type(natija).__name__} qaytdi")
        return natija
    return orov


@turlarni_tekshir
def chegirma(narx: float, foiz: int) -> float:
    return narx * (100 - foiz) / 100


print("=== 1. Chegarada ushlash ===")
print(f"  to'g'ri: chegirma(10_000.0, 15) = {chegirma(10_000.0, 15)}")
for args in [("10000", 15), (10_000.0, "15")]:
    try:
        chegirma(*args)
    except TypeError as xato:
        print(f"  {args} → TypeError: {xato}")

print("\n=== 2. Umumiy turlarni isinstance tekshira olmaydi ===")


def ballar(qiymatlar: list[int]) -> float:
    return sum(qiymatlar) / len(qiymatlar)


izohlar = typing.get_type_hints(ballar)
print(f"  annotatsiya: {izohlar['qiymatlar']}")
print(f"  isinstance([1, 2], list[int]) ni to'g'ridan-to'g'ri ishlatib bo'ladimi:", end=" ")
try:
    isinstance([1, 2], izohlar["qiymatlar"])
    print("ha")
except TypeError as xato:
    print(f"yo'q — TypeError: {xato}")
print(f"  faqat asosini tekshirish mumkin: isinstance([1, 2], {typing.get_origin(izohlar['qiymatlar']).__name__}) = "
      f"{isinstance([1, 2], typing.get_origin(izohlar['qiymatlar']))}")
print(f"  elementlarni tekshirish — har element uchun sikl: {all(isinstance(x, int) for x in [1, 2, 3])}")

print("\n=== 3. Narxi ===")


def toza(narx: float, foiz: int) -> float:
    return narx * (100 - foiz) / 100


tekshiruvli = turlarni_tekshir(toza)


def olch(f, takror=200_000, urinish=3):
    eng = float("inf")
    for _ in range(urinish):
        bosh = time.perf_counter()
        for _ in range(takror):
            f(10_000.0, 15)
        eng = min(eng, time.perf_counter() - bosh)
    return eng


t_toza, t_tekshiruvli = olch(toza), olch(tekshiruvli)
print(f"  natijalar bir xil: {toza(10_000.0, 15) == tekshiruvli(10_000.0, 15)}")
print(f"  tekshiruvli variant kamida 2 barobar sekin: {t_tekshiruvli / t_toza >= 2}")
print("  ⭐ shuning uchun: chegarada (API, fayl, forma) tekshiring, ichki issiq funksiyalarda emas")

=== 1. Chegarada ushlash ===
  to'g'ri: chegirma(10_000.0, 15) = 8500.0
  ('10000', 15) → TypeError: chegirma(): narx uchun float kutildi, str keldi
  (10000.0, '15') → TypeError: chegirma(): foiz uchun int kutildi, str keldi

=== 2. Umumiy turlarni isinstance tekshira olmaydi ===
  annotatsiya: list[int]
  isinstance([1, 2], list[int]) ni to'g'ridan-to'g'ri ishlatib bo'ladimi: yo'q — TypeError: isinstance() argument 2 cannot be a parameterized generic
  faqat asosini tekshirish mumkin: isinstance([1, 2], list) = True
  elementlarni tekshirish — har element uchun sikl: True

=== 3. Narxi ===
  natijalar bir xil: True
  tekshiruvli variant kamida 2 barobar sekin: True
  ⭐ shuning uchun: chegarada (API, fayl, forma) tekshiring, ichki issiq funksiyalarda emas

"""AST: funksiyalar va ularning annotatsiya qamrovi; ommaviy/ichki; chaqiruvlar soni bo'yicha ustuvorlik; hisobot."""

import ast
from collections import Counter

MANBA = '''
"""To'lov moduli."""
from decimal import Decimal

SOLIQ = Decimal("0.12")

def komissiya(summa):
    return summa * Decimal("0.02")

def _yaxlitla(qiymat: Decimal) -> Decimal:
    return round(qiymat, 2)

def hisobla(summa: Decimal, foiz: Decimal) -> Decimal:
    return _yaxlitla(summa * foiz + komissiya(summa))

def hisobot(buyurtmalar):
    jami = Decimal(0)
    for b in buyurtmalar:
        jami += hisobla(b["summa"], SOLIQ) + komissiya(b["summa"])
    return _yaxlitla(jami)

class Hisob:
    def __init__(self, egasi, balans=Decimal(0)):
        self.egasi = egasi
        self.balans = balans

    def yech(self, summa: Decimal) -> bool:
        if summa > self.balans:
            return False
        self.balans -= summa + komissiya(summa)
        return True
'''


def qamrov(manba):
    daraxt = ast.parse(manba)
    chaqiruvlar = Counter(t.func.id for t in ast.walk(daraxt) if isinstance(t, ast.Call) and isinstance(t.func, ast.Name))
    hisobot = []
    for tugun in ast.walk(daraxt):
        if not isinstance(tugun, (ast.FunctionDef, ast.AsyncFunctionDef)):
            continue
        argumentlar = [a for a in tugun.args.args + tugun.args.kwonlyargs if a.arg not in {"self", "cls"}]
        izohlangan = sum(a.annotation is not None for a in argumentlar)
        jami = len(argumentlar) + 1                       # + qaytish qiymati
        bor = izohlangan + (tugun.returns is not None)
        hisobot.append({
            "nom": tugun.name,
            "qator": tugun.lineno,
            "ommaviy": not tugun.name.startswith("_"),
            "qamrov": bor / jami,
            "chaqiruvlar": chaqiruvlar.get(tugun.name, 0),
        })
    return hisobot


def ustuvorlik(yozuv):
    """Qamrovi past, ko'p chaqiriladigan va ommaviy funksiyalar birinchi."""
    return (yozuv["qamrov"], -yozuv["chaqiruvlar"], not yozuv["ommaviy"])


yozuvlar = qamrov(MANBA)

print("=== 1. Funksiyalar bo'yicha qamrov ===")
print(f"  {'funksiya':14} {'qator':>5} {'ommaviy':>8} {'qamrov':>7} {'chaqiruvlar':>11}")
for y in sorted(yozuvlar, key=lambda y: y["qator"]):
    print(f"  {y['nom']:14} {y['qator']:>5} {str(y['ommaviy']):>8} {y['qamrov']:>6.0%} {y['chaqiruvlar']:>11}")

jami_qamrov = sum(y["qamrov"] for y in yozuvlar) / len(yozuvlar)
print(f"\n  modul bo'yicha o'rtacha qamrov: {jami_qamrov:.0%}")
print(f"  to'liq annotatsiyalangan funksiyalar: {sum(1 for y in yozuvlar if y['qamrov'] == 1)} / {len(yozuvlar)}")

print("\n=== 2. Nimadan boshlash kerak ===")
for orin, y in enumerate(sorted(yozuvlar, key=ustuvorlik)[:3], 1):
    sabab = []
    if y["qamrov"] == 0:
        sabab.append("umuman annotatsiyasiz")
    if y["chaqiruvlar"] >= 2:
        sabab.append(f"{y['chaqiruvlar']} joyda chaqiriladi")
    if y["ommaviy"]:
        sabab.append("ommaviy API")
    print(f"  {orin}. {y['nom']} (qator {y['qator']}) — {', '.join(sabab)}")

print("\n=== 3. Tavsiya ===")
print("  ⭐ chegaradagi va ko'p chaqiriladigan funksiyalardan boshlang")
print("  ⭐ har bosqichda tekshiruvchini ishga tushiring (13.7-dars), qamrovni CI da kuzating")

=== 1. Funksiyalar bo'yicha qamrov ===
  funksiya       qator  ommaviy  qamrov chaqiruvlar
  komissiya          7     True     0%           3
  _yaxlitla         10    False   100%           2
  hisobla           13     True   100%           1
  hisobot           16     True     0%           0
  __init__          23    False     0%           0
  yech              27     True   100%           0

  modul bo'yicha o'rtacha qamrov: 50%
  to'liq annotatsiyalangan funksiyalar: 3 / 6

=== 2. Nimadan boshlash kerak ===
  1. komissiya (qator 7) — umuman annotatsiyasiz, 3 joyda chaqiriladi, ommaviy API
  2. hisobot (qator 16) — umuman annotatsiyasiz, ommaviy API
  3. __init__ (qator 23) — umuman annotatsiyasiz

=== 3. Tavsiya ===
  ⭐ chegaradagi va ko'p chaqiriladigan funksiyalardan boshlang
  ⭐ har bosqichda tekshiruvchini ishga tushiring (13.7-dars), qamrovni CI da kuzating

def narx_qoshish(narx: float) -> None:   # ❌ tashqi JSON dan str kelishi mumkin
    ...
narx = float(sorov["narx"])              # ✅ chegarada o'girish yoki validatsiya (13.8)

isinstance(x, list[int])                 # ❌ TypeError
isinstance(x, list) and all(isinstance(i, int) for i in x)   # ✅ (narxini biling)

def orov(*a):
    izohlar = typing.get_type_hints(f)    # ❌ har chaqiruvda qayta hisoblash
izohlar = typing.get_type_hints(f)        # ✅ dekorator yaratilganda bir marta

from ogir_modul import Tur                # ❌ ish vaqtida ham yuklanadi
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from ogir_modul import Tur            # ✅

def ishla(malumot: Any) -> Any:          # ⚠️ tekshiruvchi hech narsa ayta olmaydi

def yubor(x: dict) -> bool: ...          # ⚠️ qanday kalitlar? nima qaytadi?
def yubor(xabar: Xabar) -> bool:         # ✅ aniq tur + docstring
    """True — yuborildi, False — navbatga qo'yildi."""

@turlarni_tekshir                        # ⚠️ issiq funksiyada sezilarli narx
def kichik_yordamchi(x: int) -> int: ...

from typing import List, Dict, Optional
def f(x: List[int]) -> Optional[Dict[str, int]]: ...   # ⚠️ eskirgan uslub
def f(x: list[int]) -> dict[str, int] | None: ...      # ✅ 3.10+ (13.2, 13.3-darslar)

import typing
1.  def f(a: int) -> str:
        return a
    print(f(5))
2.  print(f.__annotations__)
3.  def g(x: "int") -> "int":
        return x
    print(typing.get_type_hints(g))
4.  def h():
        y: int = 1
        return y
    print(h.__annotations__)
5.  class K:
        a: int
        b: str = "x"
    print(K.__annotations__)
6.  print(hasattr(K, "a"), hasattr(K, "b"))
7.  print(1 + True)
8.  try:
        print(1 + "2")
    except TypeError:
        print("TypeError")
9.  print(isinstance(True, int))
10. print(type([1, 2]) is list, isinstance([1, 2], list))
11. try:
        isinstance([1], list[int])
    except TypeError:
        print("TypeError")
12. import inspect
    print(str(inspect.signature(f)))

1.  def narx_ol(sorov: dict) -> float:
        return sorov["narx"]          # JSON dan str kelishi mumkin

2.  from ogir_kutubxona import Model
    def bashorat(model: Model, x: list[float]) -> float:
        ...

3.  import typing
    def tekshir(f):
        def orov(*a, **k):
            izohlar = typing.get_type_hints(f)
            ...
        return orov

4.  from typing import List, Optional, Dict
    def xarita(nomlar: List[str]) -> Optional[Dict[str, int]]:
        ...

5.  def ishla(malumot: typing.Any) -> typing.Any:
        return malumot["natija"]