Xatolar bilan ishlash va logging

BaseException
 ├── KeyboardInterrupt        ← Ctrl+C
 ├── SystemExit               ← sys.exit()
 └── Exception                ← oddiy xatolarning hammasi shu yerdan
      ├── ArithmeticError
      │    └── ZeroDivisionError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── OSError
      │    ├── FileNotFoundError
      │    ├── PermissionError
      │    └── ConnectionError
      │         └── TimeoutError ...
      ├── TypeError
      ├── ValueError
      │    └── UnicodeDecodeError ...
      ├── AttributeError
      ├── ImportError
      │    └── ModuleNotFoundError
      └── RuntimeError
           └── RecursionError

def read_config(path: str) -> dict:
    try:
        f = open(path, encoding="utf-8")
    except FileNotFoundError:
        print(f"{path} topilmadi, standart sozlamalar ishlatiladi")
        return {}
    else:
        # faqat try MUVAFFAQIYATLI bo'lganda ishlaydi
        with f:
            return json.load(f)
    finally:
        # HAR DOIM ishlaydi — xato bo'lsa ham, return bo'lsa ham
        print("read_config tugadi")

try:
    value = int(data[key])
except KeyError:
    value = 0
except (ValueError, TypeError) as e:       # bir nechta tip — tuple bilan
    print(f"Noto'g'ri qiymat: {e}")
    value = 0

try:
    train_model()
except:              # ❌ "yalang'och" except — Ctrl+C va sys.exit ni ham ushlaydi!
    pass
 
try:
    train_model()
except Exception:    # ❌ hali ham yomon — xato jimgina yo'qoladi
    pass

try:
    handle_request(req)
except Exception:
    log.exception("So'rovni qayta ishlashda xato: %s", req.id)   # to'liq traceback bilan
    return error_response(500)

def set_temperature(t: float) -> None:
    if not 0 <= t <= 1:
        raise ValueError(f"temperature 0 va 1 orasida bo'lishi kerak, berildi: {t}")
    ...

try:
    process(batch)
except ConnectionError:
    log.warning("Tarmoq xatosi, batch %d", batch_id)
    raise                    # o'sha istisnoni o'zgarishsiz yuqoriga uzatish

class ConfigError(Exception):
    pass
 
 
def load_config(path: str) -> dict:
    try:
        with open(path, encoding="utf-8") as f:
            return json.load(f)
    except (OSError, json.JSONDecodeError) as e:
        raise ConfigError(f"Konfiguratsiyani o'qib bo'lmadi: {path}") from e

try:
    value = config["model"]
except KeyError as e:
    e.add_note("config.yaml faylida 'model' maydoni bormi?")
    raise

class LLMError(Exception):
    """Bizning LLM klientimizning barcha xatolari uchun asos."""
 
 
class RateLimitError(LLMError):
    def __init__(self, retry_after: float):
        super().__init__(f"API limiti: {retry_after}s dan keyin qayta urinib ko'ring")
        self.retry_after = retry_after
 
 
class ContextTooLongError(LLMError):
    def __init__(self, tokens: int, limit: int):
        super().__init__(f"Kontekst juda uzun: {tokens} > {limit} token")
        self.tokens = tokens
        self.limit = limit

try:
    answer = ask_llm(prompt)
except RateLimitError as e:
    time.sleep(e.retry_after)            # aniq holat — aniq reaksiya
    answer = ask_llm(prompt)
except ContextTooLongError:
    answer = ask_llm(truncate(prompt))
except LLMError:
    answer = "Xizmat vaqtincha ishlamayapti"   # qolgan hammasi

# LBYL — oldindan tekshirish
if os.path.exists(path):
    with open(path) as f:       # ← tekshiruv va ochish orasida fayl o'chirilishi mumkin!
        data = f.read()
 
# EAFP — urinib ko'rish
try:
    with open(path) as f:
        data = f.read()
except FileNotFoundError:
    data = None

try:
    raise ExceptionGroup("bir nechta vazifa yiqildi", [
        ValueError("noto'g'ri ma'lumot"),
        TimeoutError("server javob bermadi"),
    ])
except* ValueError as eg:
    print("Qiymat xatolari:", eg.exceptions)
except* TimeoutError as eg:
    print("Timeout'lar:", eg.exceptions)

def cosine_similarity(a: list[float], b: list[float]) -> float:
    assert len(a) == len(b), f"Vektor uzunliklari farq qiladi: {len(a)} != {len(b)}"
    ...

f = open("data.txt", encoding="utf-8")
try:
    data = f.read()
finally:
    f.close()

with open("data.txt", encoding="utf-8") as f:
    data = f.read()
# bu yerda fayl albatta yopilgan — xato bo'lgan bo'lsa ham

import logging
 
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)-8s %(name)s: %(message)s",
    datefmt="%H:%M:%S",
)
 
log = logging.getLogger(__name__)     # har modulda shunday — modul nomi bilan logger
 
log.debug("batafsil ma'lumot")         # INFO darajasida ko'rinmaydi
log.info("epoch %d tugadi, loss=%.4f", 1, 0.3456)
log.warning("GPU topilmadi, CPU ishlatilmoqda")
log.error("checkpoint saqlanmadi")

07:19:13 INFO     myapp.train: epoch 1 tugadi, loss=0.3456
07:19:13 WARNING  myapp.train: GPU topilmadi, CPU ishlatilmoqda
07:19:13 ERROR    myapp.train: checkpoint saqlanmadi

log.info("user %s loaded %d rows", user_id, n)    # ✅ satr faqat kerak bo'lsa formatlanadi
log.info(f"user {user_id} loaded {n} rows")       # ⚠️ ishlaydi, lekin har doim formatlanadi

try:
    result = 1 / 0
except ZeroDivisionError:
    log.exception("Hisoblashda xato")     # ERROR darajasi + to'liq traceback

import logging
import sys
from logging.handlers import RotatingFileHandler
 
 
def setup_logging(level: str = "INFO", logfile: str = "app.log") -> None:
    fmt = logging.Formatter("%(asctime)s %(levelname)-8s %(name)s: %(message)s")
 
    console = logging.StreamHandler(sys.stderr)
    console.setFormatter(fmt)
 
    file = RotatingFileHandler(logfile, maxBytes=10_000_000, backupCount=5, encoding="utf-8")
    file.setFormatter(fmt)
 
    root = logging.getLogger()
    root.setLevel(level)
    root.handlers = [console, file]
 
    # shovqinli kutubxonalarni tinchlantirish
    logging.getLogger("httpx").setLevel(logging.WARNING)
    logging.getLogger("urllib3").setLevel(logging.WARNING)

import json
import logging
from dataclasses import dataclass, field
 
log = logging.getLogger(__name__)
 
 
class RecordError(Exception):
    """Bitta yozuvni qayta ishlab bo'lmadi."""
 
 
@dataclass
class BatchResult:
    ok: list[dict] = field(default_factory=list)
    failed: list[tuple[int, str]] = field(default_factory=list)   # (qator raqami, sabab)
 
 
def parse_record(line: str) -> dict:
    try:
        rec = json.loads(line)
    except json.JSONDecodeError as e:
        raise RecordError(f"JSON emas: {e.msg}") from e
    if not isinstance(rec, dict):
        raise RecordError("obyekt emas")
    text = rec.get("text")
    if not isinstance(text, str) or not text.strip():
        raise RecordError("'text' maydoni yo'q yoki bo'sh")
    return {"text": text.strip(), "label": rec.get("label")}
 
 
def process_lines(lines, max_failures: int = 100) -> BatchResult:
    result = BatchResult()
    for n, line in enumerate(lines, 1):
        try:
            result.ok.append(parse_record(line))
        except RecordError as e:
            log.warning("%d-qator o'tkazib yuborildi: %s", n, e)
            result.failed.append((n, str(e)))
            if len(result.failed) > max_failures:
                raise RuntimeError(f"Juda ko'p buzilgan yozuv (>{max_failures}) — fayl formati to'g'rimi?") from e
    log.info("Tayyor: %d ta yaxshi, %d ta buzilgan", len(result.ok), len(result.failed))
    return result