16.6-dars: YAML va TOML

loyiha: Wisar
port: 8000
teglar:
  - python
  - web
baza:
  host: localhost
  port: 5432

import yaml
malumot = yaml.safe_load(matn)        # ⭐ har doim safe_load
matn = yaml.safe_dump(malumot, allow_unicode=True, sort_keys=False)

literal: |
  birinchi qator
  ikkinchi qator
folded: >
  bu uzun matn
  bitta qatorga birlashadi

yaml.load(ishonchsiz)          # ❌ kod bajarishi mumkin
yaml.safe_load(ishonchsiz)     # ✅ faqat oddiy turlar; xavfli teg → ConstructorError

default: &def
  timeout: 30
  retry: 3
servis_a:
  <<: *def
  host: a.local

loyiha = "Wisar"
versiya = "1.2.0"       # satr — qo'shtirnoq majburiy
port = 8000             # int
narx = 45000.50         # float
faol = true             # bool — faqat true/false
teglar = ["python", "web"]
sana = 2026-09-17       # native date

[baza]                  # jadval (table) = lug'at
host = "localhost"
port = 5432

[baza.pool]             # ichma-ich jadval
max = 10

[[servislar]]           # jadvallar massivi = lug'atlar ro'yxati
nom = "api"
[[servislar]]
nom = "worker"

import tomllib
with open("config.toml", "rb") as f:       # ⚠️ binar rejim
    malumot = tomllib.load(f)
malumot = tomllib.loads(matn)              # satrdan

import yaml, tomllib

malumot = yaml.safe_load(yaml_matn)                 # ⭐ safe_load
yaml.safe_dump(malumot, allow_unicode=True, sort_keys=False)

with open("config.toml", "rb") as f:                # ⚠️ binar
    sozlama = tomllib.load(f)
sozlama = tomllib.loads(toml_matn, parse_float=decimal.Decimal)

import tomli_w                                       # yozish (tashqi)
tomli_w.dump(malumot, open("out.toml", "wb"))

YAML: har doim safe_load / safe_dump
YAML: yes/no/NO/1.10 — qo'shtirnoqqa oling
YAML: chekinish bo'shliq bilan, TAB emas
TOML: satr qo'shtirnoqda, faqat true/false
TOML: tomllib faqat o'qiydi, "rb" rejim
sozlama uchun: TOML (tekis), YAML (chuqur), JSON emas

"""safe_load; turlar taxmini: yes/no/on/off, Norway problem, sexagesimal, versiya, date; qo'shtirnoq bilan yechim; blok skalyarlar (| va >)."""

import yaml

SOZLAMA = """
loyiha: Wisar
versiya: 1.10
faol: yes
debug: off
port: 8000
narx: 45000.50
teglar:
  - python
  - web
mamlakatlar: [NO, SE, FI]
vaqt_belgi: 22:22
sana: 2026-09-17
literal: |
  birinchi qator
  ikkinchi qator
folded: >
  bu uzun matn
  bitta qatorga birlashadi
"""


def main() -> None:
    d = yaml.safe_load(SOZLAMA)

    print("=== 1. ⚠️ Turlar taxmini ===")
    for kalit in ("versiya", "faol", "debug", "port", "narx", "sana"):
        print(f"  {kalit:9} = {d[kalit]!r:24} ({type(d[kalit]).__name__})")

    print("\n=== 2. ⚠️ Norway problem ===")
    print(f"  mamlakatlar: [NO, SE, FI] → {d['mamlakatlar']}")
    print(f"  ⚠️ NO (Norvegiya) → {d['mamlakatlar'][0]} (bool!), SE va FI — satr")

    print("\n=== 3. ⚠️ Boshqa tuzoqlar ===")
    print(f"  versiya 1.10 → {d['versiya']!r}  ← oxirgi nol yo'qoldi (float)")
    print(f"  22:22 → {d['vaqt_belgi']!r}  ← sexagesimal: 22×60+22")
    print(f"  yes → {d['faol']}, off → {d['debug']}  ← bool, satr emas")

    print("\n=== 4. ⭐ Yechim: qo'shtirnoq ===")
    toza = yaml.safe_load("""
    versiya: "1.10"
    mamlakatlar: ["NO", "SE", "FI"]
    faol: "yes"
    """)
    print(f"  versiya: {toza['versiya']!r} ({type(toza['versiya']).__name__})")
    print(f"  mamlakatlar: {toza['mamlakatlar']}")
    print(f"  faol: {toza['faol']!r} ({type(toza['faol']).__name__})")

    print("\n=== 5. Blok skalyarlar ===")
    print(f"  literal (|): {d['literal']!r}")
    print(f"  folded (>): {d['folded']!r}")


if __name__ == "__main__":
    main()

=== 1. ⚠️ Turlar taxmini ===
  versiya   = 1.1                      (float)
  faol      = True                     (bool)
  debug     = False                    (bool)
  port      = 8000                     (int)
  narx      = 45000.5                  (float)
  sana      = datetime.date(2026, 9, 17) (date)

=== 2. ⚠️ Norway problem ===
  mamlakatlar: [NO, SE, FI] → [False, 'SE', 'FI']
  ⚠️ NO (Norvegiya) → False (bool!), SE va FI — satr

=== 3. ⚠️ Boshqa tuzoqlar ===
  versiya 1.10 → 1.1  ← oxirgi nol yo'qoldi (float)
  22:22 → 1342  ← sexagesimal: 22×60+22
  yes → True, off → False  ← bool, satr emas

=== 4. ⭐ Yechim: qo'shtirnoq ===
  versiya: '1.10' (str)
  mamlakatlar: ['NO', 'SE', 'FI']
  faol: 'yes' (str)

=== 5. Blok skalyarlar ===
  literal (|): 'birinchi qator\nikkinchi qator\n'
  folded (>): 'bu uzun matn bitta qatorga birlashadi\n'

"""safe_load xavfli tegni bloklaydi; safe_dump va allow_unicode; sort_keys; anchor, havola va merge (<<); ishonchsiz YAML da anchor kengayishi haqida eslatma."""

import yaml


def main() -> None:
    print("=== 1. ⚠️ safe_load xavfsizligi ===")
    xavfli = "!!python/object/apply:os.system ['echo hujum']"
    try:
        yaml.safe_load(xavfli)
    except yaml.YAMLError as xato:
        print(f"  safe_load bloklaydi: {type(xato).__name__}")
    print("  ⚠️ yaml.load(xavfli) esa buyruqni BAJARADI — hech qachon ishonchsizga yaml.load")

    print("\n=== 2. safe_dump ===")
    malumot = {"ism": "Oʻgʻiloy", "yosh": 25, "teglar": ["python", "web"], "faol": True}
    print("  allow_unicode=False (sukut) — ASCII escape:")
    for qator in yaml.safe_dump(malumot, sort_keys=True).splitlines():
        print(f"    {qator}")
    print("  ⭐ allow_unicode=True, sort_keys=False:")
    for qator in yaml.safe_dump(malumot, allow_unicode=True, sort_keys=False).splitlines():
        print(f"    {qator}")

    print("\n=== 3. Anchor va merge ===")
    konfig = """
    default: &sukut
      timeout: 30
      retry: 3
      log_level: info
    servis_api:
      <<: *sukut
      host: api.local
    servis_worker:
      <<: *sukut
      host: worker.local
      retry: 5
    """
    d = yaml.safe_load(konfig)
    print(f"  servis_api:    {d['servis_api']}")
    print(f"  servis_worker: {d['servis_worker']}  ← retry override qilindi")
    print("  ⚠️ anchor lar ichma-ich takrorlansa kengayadi — ishonchsiz YAML da DoS xavfi")


if __name__ == "__main__":
    main()

=== 1. ⚠️ safe_load xavfsizligi ===
  safe_load bloklaydi: ConstructorError
  ⚠️ yaml.load(xavfli) esa buyruqni BAJARADI — hech qachon ishonchsizga yaml.load

=== 2. safe_dump ===
  allow_unicode=False (sukut) — ASCII escape:
    faol: true
    ism: "O\u02BBg\u02BBiloy"
    teglar:
    - python
    - web
    yosh: 25
  ⭐ allow_unicode=True, sort_keys=False:
    ism: Oʻgʻiloy
    yosh: 25
    teglar:
    - python
    - web
    faol: true

=== 3. Anchor va merge ===
  servis_api:    {'timeout': 30, 'retry': 3, 'log_level': 'info', 'host': 'api.local'}
  servis_worker: {'timeout': 30, 'retry': 5, 'log_level': 'info', 'host': 'worker.local'}  ← retry override qilindi
  ⚠️ anchor lar ichma-ich takrorlansa kengayadi — ishonchsiz YAML da DoS xavfi

"""tomllib.loads/load; qat'iy turlar; native date/datetime; jadvallar va jadvallar massivi; pastki chiziqli sonlar; xatolar: takroriy kalit, null yo'q, satr qo'shtirnoqsiz; parse_float; tomli_w bilan yozish."""

import datetime
import io
import tomllib
from decimal import Decimal

import tomli_w

TOML = """# Wisar loyiha sozlamasi
loyiha = "Wisar"
versiya = "1.2.0"
port = 8000
narx = 45000.50
faol = true
katta = 1_000_000
teglar = ["python", "web"]
sana = 2026-09-17
vaqt = 2026-09-17T09:30:00+05:00

[baza]
host = "localhost"
port = 5432

[baza.pool]
min = 1
max = 10

[[servislar]]
nom = "api"
port = 8001

[[servislar]]
nom = "worker"
port = 8002
"""


def main() -> None:
    d = tomllib.loads(TOML)

    print("=== 1. ⭐ Qat'iy turlar ===")
    for kalit in ("versiya", "port", "narx", "faol", "katta"):
        print(f"  {kalit:8} = {d[kalit]!r:14} ({type(d[kalit]).__name__})")
    print(f"  ⭐ versiya '1.2.0' — satr bo'lib qoladi (YAML dan farqli)")

    print("\n=== 2. Native sana va vaqt ===")
    print(f"  sana: {d['sana']} ({type(d['sana']).__name__})")
    print(f"  vaqt: {d['vaqt']} mintaqa: {d['vaqt'].tzinfo}")

    print("\n=== 3. Jadvallar va massivlar ===")
    print(f"  baza: {d['baza']}")
    print(f"  baza.pool.max: {d['baza']['pool']['max']}")
    print(f"  servislar (jadvallar massivi): {[s['nom'] for s in d['servislar']]}")

    print("\n=== 4. ⚠️ Xatolar ===")
    for nom, matn in [("takroriy kalit", "a = 1\na = 2"), ("null yo'q", "a = null"),
                      ("qo'shtirnoqsiz satr", "versiya = 1.2.0")]:
        try:
            tomllib.loads(matn)
        except tomllib.TOMLDecodeError as xato:
            print(f"  {nom:20}: TOMLDecodeError: {str(xato).split(' (')[0]}")

    print("\n=== 5. parse_float va bytes ===")
    d2 = tomllib.loads("narx = 0.1", parse_float=Decimal)
    print(f"  parse_float=Decimal: {d2['narx']!r}")
    print(f"  tomllib.load bytes: {tomllib.load(io.BytesIO(b'x = 42'))['x']}")

    print("\n=== 6. tomli_w bilan yozish ===")
    yangi = {"loyiha": "Wisar", "port": 8000, "faol": True,
             "teglar": ["a", "b"], "baza": {"host": "localhost", "port": 5432}}
    chiqish = tomli_w.dumps(yangi)
    for qator in chiqish.splitlines():
        print(f"  {qator}")
    print(f"  aylanib qaytish teng: {tomllib.loads(chiqish) == yangi}")


if __name__ == "__main__":
    main()

=== 1. ⭐ Qat'iy turlar ===
  versiya  = '1.2.0'        (str)
  port     = 8000           (int)
  narx     = 45000.5        (float)
  faol     = True           (bool)
  katta    = 1000000        (int)
  ⭐ versiya '1.2.0' — satr bo'lib qoladi (YAML dan farqli)

=== 2. Native sana va vaqt ===
  sana: 2026-09-17 (date)
  vaqt: 2026-09-17 09:30:00+05:00 mintaqa: UTC+05:00

=== 3. Jadvallar va massivlar ===
  baza: {'host': 'localhost', 'port': 5432, 'pool': {'min': 1, 'max': 10}}
  baza.pool.max: 10
  servislar (jadvallar massivi): ['api', 'worker']

=== 4. ⚠️ Xatolar ===
  takroriy kalit      : TOMLDecodeError: Cannot overwrite a value
  null yo'q           : TOMLDecodeError: Invalid value
  qo'shtirnoqsiz satr : TOMLDecodeError: Expected newline or end of document after a statement

=== 5. parse_float va bytes ===
  parse_float=Decimal: Decimal('0.1')
  tomllib.load bytes: 42

=== 6. tomli_w bilan yozish ===
  loyiha = "Wisar"
  port = 8000
  faol = true
  teglar = [
      "a",
      "b",
  ]

  [baza]
  host = "localhost"
  port = 5432
  aylanib qaytish teng: True

"""TOML va YAML dan sozlama yuklash; ichma-ich birlashtirish; sxema tekshiruvi (tur, majburiylik, oraliq); format aniqlash; aniq xato xabarlari."""

import tomllib
from typing import Any

import yaml

SUKUT: dict[str, Any] = {
    "server": {"host": "0.0.0.0", "port": 8000, "workers": 4},
    "baza": {"host": "localhost", "port": 5432, "pool": {"min": 1, "max": 10}},
    "log": {"level": "info"},
}

# (yo'l, tur, tekshiruv)
SXEMA = [
    (("server", "port"), int, lambda v: 1 <= v <= 65535),
    (("server", "workers"), int, lambda v: 1 <= v <= 64),
    (("baza", "port"), int, lambda v: 1 <= v <= 65535),
    (("baza", "pool", "max"), int, lambda v: v >= 1),
    (("log", "level"), str, lambda v: v in {"debug", "info", "warning", "error"}),
]


def birlashtir(asos: dict, ustki: dict) -> dict:
    natija = {k: (v.copy() if isinstance(v, dict) else v) for k, v in asos.items()}
    for kalit, qiymat in ustki.items():
        if isinstance(qiymat, dict) and isinstance(natija.get(kalit), dict):
            natija[kalit] = birlashtir(natija[kalit], qiymat)
        else:
            natija[kalit] = qiymat
    return natija


def yukla(matn: str, format: str) -> dict:
    if format == "toml":
        return tomllib.loads(matn)
    if format == "yaml":
        d = yaml.safe_load(matn)
        if not isinstance(d, dict):
            raise ValueError("sozlama lug'at bo'lishi kerak")
        return d
    raise ValueError(f"noma'lum format: {format}")


def ol(d: dict, yol: tuple):
    for qism in yol:
        d = d[qism]
    return d


def tekshir(sozlama: dict) -> list[str]:
    xatolar = []
    for yol, tur, shart in SXEMA:
        nom = ".".join(yol)
        try:
            qiymat = ol(sozlama, yol)
        except (KeyError, TypeError):
            xatolar.append(f"{nom}: maydon yo'q")
            continue
        if isinstance(qiymat, bool) or not isinstance(qiymat, tur):
            xatolar.append(f"{nom}: {tur.__name__} kutilgan, {type(qiymat).__name__} keldi ({qiymat!r})")
        elif not shart(qiymat):
            xatolar.append(f"{nom}: qiymat oraliqdan tashqari ({qiymat!r})")
    return xatolar


def main() -> None:
    print("=== 1. TOML sozlama (qisman) ===")
    toml_matn = """
    [server]
    port = 9000
    workers = 8

    [baza]
    host = "db.example"

    [log]
    level = "debug"
    """
    sozlama = birlashtir(SUKUT, yukla(toml_matn, "toml"))
    print(f"  server: {sozlama['server']}")
    print(f"  baza:   {sozlama['baza']}  ← host o'zgardi, pool sukutdan")
    print(f"  log:    {sozlama['log']}")
    print(f"  tekshiruv: {tekshir(sozlama) or 'toza ✅'}")

    print("\n=== 2. Xatoli sozlama ===")
    yomon = """
    [server]
    port = 99999
    workers = "ko'p"

    [log]
    level = "trace"
    """
    sozlama = birlashtir(SUKUT, yukla(yomon, "toml"))
    for xato in tekshir(sozlama):
        print(f"  ❌ {xato}")

    print("\n=== 3. YAML muqobil (tuzoq bilan) ===")
    yaml_matn = """
    server:
      port: 8080
      workers: 4
    log:
      level: info
    faol: yes
    """
    d = yukla(yaml_matn, "yaml")
    sozlama = birlashtir(SUKUT, d)
    print(f"  server.port: {sozlama['server']['port']}")
    print(f"  ⚠️ 'faol: yes' → {sozlama['faol']!r} ({type(sozlama['faol']).__name__}) — YAML tuzog'i")
    print(f"  tekshiruv: {tekshir(sozlama) or 'toza ✅'}")

    print("\n=== 4. Xulosa ===")
    print("  TOML — qat'iy turlar, xato darhol; YAML — moslashuvchan, lekin tuzoqli")
    print("  ikkalasi ham: yuklashdan keyin sxema bilan tekshirish shart")


if __name__ == "__main__":
    main()

=== 1. TOML sozlama (qisman) ===
  server: {'host': '0.0.0.0', 'port': 9000, 'workers': 8}
  baza:   {'host': 'db.example', 'port': 5432, 'pool': {'min': 1, 'max': 10}}  ← host o'zgardi, pool sukutdan
  log:    {'level': 'debug'}
  tekshiruv: toza ✅

=== 2. Xatoli sozlama ===
  ❌ server.port: qiymat oraliqdan tashqari (99999)
  ❌ server.workers: int kutilgan, str keldi ("ko'p")
  ❌ log.level: qiymat oraliqdan tashqari ('trace')

=== 3. YAML muqobil (tuzoq bilan) ===
  server.port: 8080
  ⚠️ 'faol: yes' → True (bool) — YAML tuzog'i
  tekshiruv: toza ✅

=== 4. Xulosa ===
  TOML — qat'iy turlar, xato darhol; YAML — moslashuvchan, lekin tuzoqli
  ikkalasi ham: yuklashdan keyin sxema bilan tekshirish shart

yaml.load(tashqi)                                   # ❌ kod bajaradi
yaml.safe_load(tashqi)                              # ✅

mamlakat: NO        # ❌ False
mamlakat: "NO"      # ✅ satr
enabled: yes        # ❌ True
enabled: "yes"      # ✅ (yoki: enabled: true — haqiqiy bool)

tomllib.load(open("c.toml"))                        # ❌ TypeError (str keladi)
tomllib.load(open("c.toml", "rb"))                  # ✅ binar

versiya = 1.2.0     # ❌ TOMLDecodeError
versiya = "1.2.0"   # ✅

tomllib.dumps(d)                                    # ❌ AttributeError
tomli_w.dumps(d)                                    # ✅

	kalit: qiymat   # ❌ TAB — ParserError
  kalit: qiymat     # ✅ bo'shliq

port = yaml.safe_load(matn)["port"]                 # ❌ tur/oraliq noma'lum
# ✅ yuklashdan keyin sxema tekshiruvi (Misol 4, yoki pydantic 13.8)

yaml.safe_dump(d)                                   # "Oʻ..." — o'qib bo'lmaydi
yaml.safe_dump(d, allow_unicode=True)               # ✅ Oʻgʻiloy

import yaml, tomllib
1.  print(yaml.safe_load("x: yes")["x"])
2.  print(yaml.safe_load("x: NO")["x"])
3.  print(yaml.safe_load("x: 1.10")["x"])
4.  print(yaml.safe_load('x: "yes"')["x"])
5.  print(type(yaml.safe_load("x: 2026-09-17")["x"]).__name__)
6.  print(yaml.safe_load("x: 22:22")["x"])
7.  print(tomllib.loads('x = "1.2.0"')["x"])
8.  print(type(tomllib.loads("x = 2026-09-17")["x"]).__name__)
9.  print(tomllib.loads("x = 1_000")["x"])
10. print(tomllib.loads("[a]\nb = 1")["a"]["b"])
11. try:
        tomllib.loads("a = 1\na = 2")
    except tomllib.TOMLDecodeError:
        print("xato")
12. print(yaml.safe_load("a: [1, 2]\nb: {x: 1}"))

1.  def yukla(matn):
        return yaml.load(matn)                      # foydalanuvchi yuborgan

2.  def toml_oqi(yol):
        with open(yol) as f:
            return tomllib.load(f)

3.  # config.yaml:
    #   mamlakatlar: [NO, US, GB]
    #   versiya: 2.10
    def oqi(yaml_matn):
        d = yaml.safe_load(yaml_matn)
        return d["mamlakatlar"], d["versiya"]       # NO va 2.10 kutilgan

4.  def saqla(yol, sozlama):
        with open(yol, "w") as f:
            tomllib.dump(sozlama, f)

5.  def dump_yaml(malumot):
        return yaml.safe_dump(malumot)              # o'zbekcha matn bor