15.15-dars: argparse — CLI

parser.add_argument("--tozala", type=bool, default=False)

import argparse

parser = argparse.ArgumentParser(prog="import", description="CSV ni bazaga import qilish")
parser.add_argument("fayl")                                   # pozitsion — majburiy
parser.add_argument("-n", "--soni", type=int, default=100)    # ixtiyoriy
parser.add_argument("--format", choices=["csv", "tsv"], default="csv")
args = parser.parse_args()          # sys.argv[1:] dan
args = parser.parse_args(["a.csv", "-n", "5"])   # ⭐ testlarda — aniq ro'yxat
args.fayl, args.soni

def musbat_son(qiymat: str) -> int:
    son = int(qiymat)
    if son <= 0:
        raise argparse.ArgumentTypeError(f"musbat son kerak: {qiymat}")
    return son

parser = argparse.ArgumentParser(prog="vazifa")
buyruqlar = parser.add_subparsers(dest="buyruq", required=True)

qosh = buyruqlar.add_parser("qosh", help="yangi vazifa")
qosh.add_argument("matn")
qosh.set_defaults(ishlovchi=vazifa_qosh)       # ⭐ har buyruqqa funksiya

args = parser.parse_args()
return args.ishlovchi(args)

umumiy = argparse.ArgumentParser(add_help=False)
umumiy.add_argument("--fayl", type=Path)
buyruqlar.add_parser("qosh", parents=[umumiy])

def parser_yarat() -> argparse.ArgumentParser: ...

def main(argv: list[str] | None = None) -> int:
    args = parser_yarat().parse_args(argv)     # None → sys.argv[1:]
    try:
        return args.ishlovchi(args)
    except FoydalanuvchiXatosi as x:
        print(f"xato: {x}", file=sys.stderr)
        return 1

if __name__ == "__main__":
    sys.exit(main())

import argparse

p = argparse.ArgumentParser(prog="dastur", description="...")
p.add_argument("kirish", type=Path)
p.add_argument("-n", "--soni", type=int, default=10, help="soni (sukut: %(default)s)")
p.add_argument("-v", "--verbose", action="count", default=0)
p.add_argument("--quruq", action="store_true")
p.add_argument("--rang", action=argparse.BooleanOptionalAction, default=True)
p.add_argument("--format", choices=["json", "csv"], default="json")
g = p.add_mutually_exclusive_group(); g.add_argument("--tez"); g.add_argument("--aniq")

sub = p.add_subparsers(dest="buyruq", required=True)
b = sub.add_parser("qosh"); b.set_defaults(ishlovchi=qosh)

args = p.parse_args(argv)

mantiqiy bayroq — store_true / BooleanOptionalAction, type=bool emas
main(argv) -> int — testlanadigan
buyruq — set_defaults(ishlovchi=...)
argumentlararo shart — parse_args dan keyin parser.error
noto'g'ri foydalanish — kod 2 (argparse o'zi)
prog ni aniq bering — yordam matni barqaror

"""Pozitsion va ixtiyoriy; yozish shakllari; type, default, choices; store_true, count, append, nargs, BooleanOptionalAction; vars(); yordam matni."""

import argparse
from pathlib import Path


def parser_yarat() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(prog="import", description="CSV faylni bazaga import qilish", color=False)
    p.add_argument("fayl", type=Path, help="kirish fayli")
    p.add_argument("-n", "--soni", type=int, default="100", help="bir paketdagi qatorlar (sukut: %(default)s)")
    p.add_argument("-v", "--verbose", action="count", default=0, help="batafsil chiqish (-vv, -vvv)")
    p.add_argument("--quruq", action="store_true", help="bazaga yozmasdan tekshirish")
    p.add_argument("--rang", action=argparse.BooleanOptionalAction, default=True, help="rangli chiqish")
    p.add_argument("--format", choices=["csv", "tsv"], default="csv")
    p.add_argument("--ustun", action="append", default=[], metavar="NOM", help="faqat shu ustunlar (takrorlanadi)")
    p.add_argument("--sana", nargs=2, metavar=("BOSHI", "OXIRI"), help="sana oralig'i")
    p.add_argument("--kodlash", nargs="?", const="utf-8", default=None)
    return p


def main() -> None:
    p = parser_yarat()

    print("=== 1. Oddiy ===")
    args = p.parse_args(["sotuv.csv"])
    print(f"  {vars(args) | {'fayl': f'Path({args.fayl.as_posix()!r})'}}")
    print(f"  soni turi: {type(args.soni).__name__} (sukut '100' satr edi — type orqali o'tdi)")

    print("\n=== 2. Yozish shakllari bir xil ===")
    for argv in (["a.csv", "-n", "5"], ["a.csv", "-n5"], ["a.csv", "--soni", "5"], ["a.csv", "--soni=5"], ["-n", "5", "a.csv"]):
        print(f"  {' '.join(argv):20} → soni={p.parse_args(argv).soni}")

    print("\n=== 3. Amallar ===")
    args = p.parse_args(["a.csv", "-vvv", "--quruq", "--no-rang", "--ustun", "sana", "--ustun", "summa",
                         "--sana", "2026-09-01", "2026-09-30", "--kodlash"])
    print(f"  verbose={args.verbose}, quruq={args.quruq}, rang={args.rang}")
    print(f"  ustun={args.ustun}, sana={args.sana}, kodlash={args.kodlash!r}")
    print(f"  --kodlash berilmasa: {p.parse_args(['a.csv']).kodlash!r}, qiymat bilan: {p.parse_args(['a.csv', '--kodlash', 'cp1251']).kodlash!r}")

    print("\n=== 4. '--' dan keyin ===")
    print(f"  fayl nomi '-yashirin.csv': {p.parse_args(['--', '-yashirin.csv']).fayl}")

    print("\n=== 5. Yordam matni ===")
    for qator in p.format_help().splitlines():
        print(f"  {qator}")


if __name__ == "__main__":
    main()

=== 1. Oddiy ===
  {'fayl': "Path('sotuv.csv')", 'soni': 100, 'verbose': 0, 'quruq': False, 'rang': True, 'format': 'csv', 'ustun': [], 'sana': None, 'kodlash': None}
  soni turi: int (sukut '100' satr edi — type orqali o'tdi)

=== 2. Yozish shakllari bir xil ===
  a.csv -n 5           → soni=5
  a.csv -n5            → soni=5
  a.csv --soni 5       → soni=5
  a.csv --soni=5       → soni=5
  -n 5 a.csv           → soni=5

=== 3. Amallar ===
  verbose=3, quruq=True, rang=False
  ustun=['sana', 'summa'], sana=['2026-09-01', '2026-09-30'], kodlash='utf-8'
  --kodlash berilmasa: None, qiymat bilan: 'cp1251'

=== 4. '--' dan keyin ===
  fayl nomi '-yashirin.csv': -yashirin.csv

=== 5. Yordam matni ===
  usage: import [-h] [-n SONI] [-v] [--quruq] [--rang | --no-rang]
                [--format {csv,tsv}] [--ustun NOM] [--sana BOSHI OXIRI]
                [--kodlash [KODLASH]]
                fayl

  CSV faylni bazaga import qilish

  positional arguments:
    fayl                 kirish fayli

  options:
    -h, --help           show this help message and exit
    -n, --soni SONI      bir paketdagi qatorlar (sukut: 100)
    -v, --verbose        batafsil chiqish (-vv, -vvv)
    --quruq              bazaga yozmasdan tekshirish
    --rang, --no-rang    rangli chiqish
    --format {csv,tsv}
    --ustun NOM          faqat shu ustunlar (takrorlanadi)
    --sana BOSHI OXIRI   sana oralig'i
    --kodlash [KODLASH]

"""Xato xabarlari va kod 2; type=bool tuzog'i; ArgumentTypeError; o'zaro istisno guruhi; argumentlararo tekshiruv parser.error bilan; exit_on_error=False; parse_known_args; 3.14 suggest_on_error."""

import argparse
import contextlib
import io
from datetime import date


def xato_ushla(parser: argparse.ArgumentParser, argv: list[str]) -> str:
    oqim = io.StringIO()
    with contextlib.redirect_stderr(oqim):
        try:
            parser.parse_args(argv)
        except SystemExit as chiqish:
            return f"kod {chiqish.code}: {oqim.getvalue().strip().splitlines()[-1]}"
    return "xato yo'q"


def musbat_son(qiymat: str) -> int:
    try:
        son = int(qiymat)
    except ValueError:
        raise argparse.ArgumentTypeError(f"son kerak: {qiymat!r}") from None
    if son <= 0:
        raise argparse.ArgumentTypeError(f"musbat son kerak: {qiymat}")
    return son


def main() -> None:
    p = argparse.ArgumentParser(prog="hisobot", color=False)
    p.add_argument("fayl")
    p.add_argument("--soni", type=musbat_son, default=10)
    p.add_argument("--format", choices=["json", "csv"], default="json")
    p.add_argument("--boshi", type=date.fromisoformat)
    p.add_argument("--oxiri", type=date.fromisoformat)
    guruh = p.add_mutually_exclusive_group()
    guruh.add_argument("--jim", action="store_true")
    guruh.add_argument("--batafsil", action="store_true")

    print("=== 1. Standart xatolar (kod 2) ===")
    for argv in ([], ["a", "--soni", "besh"], ["a", "--soni", "-3"], ["a", "--format", "xml"],
                 ["a", "--nomalum"], ["a", "--jim", "--batafsil"], ["a", "--boshi", "17.09.2026"]):
        korinish = " ".join(argv) or "(bo'sh)"
        print(f"  {korinish:26} → {xato_ushla(p, argv)}")

    print("\n=== 2. ⚠️ type=bool ===")
    yomon = argparse.ArgumentParser(prog="import", color=False)
    yomon.add_argument("--tozala", type=bool, default=False)
    print(f"  --tozala False → {yomon.parse_args(['--tozala', 'False']).tozala}")
    print(f"  --tozala 0     → {yomon.parse_args(['--tozala', '0']).tozala}")
    yaxshi = argparse.ArgumentParser(prog="import", color=False)
    yaxshi.add_argument("--tozala", action=argparse.BooleanOptionalAction, default=False)
    print(f"  BooleanOptionalAction: --tozala → {yaxshi.parse_args(['--tozala']).tozala}, "
          f"--no-tozala → {yaxshi.parse_args(['--no-tozala']).tozala}, berilmasa → {yaxshi.parse_args([]).tozala}")

    print("\n=== 3. Argumentlararo tekshiruv ===")

    def tahlil(argv: list[str]) -> argparse.Namespace:
        args = p.parse_args(argv)
        if args.boshi and args.oxiri and args.oxiri < args.boshi:
            p.error(f"--oxiri ({args.oxiri}) --boshi ({args.boshi}) dan oldin bo'lishi mumkin emas")
        return args

    oqim = io.StringIO()
    with contextlib.redirect_stderr(oqim):
        try:
            tahlil(["a", "--boshi", "2026-09-30", "--oxiri", "2026-09-01"])
        except SystemExit as chiqish:
            print(f"  kod {chiqish.code}: {oqim.getvalue().strip().splitlines()[-1]}")

    print("\n=== 4. exit_on_error=False ===")
    boshqariladigan = argparse.ArgumentParser(prog="api", exit_on_error=False, color=False)
    boshqariladigan.add_argument("--port", type=int)
    try:
        boshqariladigan.parse_args(["--port", "sakkiz"])
    except argparse.ArgumentError as xato:
        print(f"  ArgumentError: {xato} — dastur o'zi hal qiladi (masalan, veb-forma)")

    print("\n=== 5. parse_known_args ===")
    args, qolgan = p.parse_known_args(["a", "--soni", "5", "--pytest-bayroq", "x"])
    print(f"  ma'lum: soni={args.soni}, noma'lum: {qolgan}")

    print("\n=== 6. 3.14: suggest_on_error ===")
    taklifli = argparse.ArgumentParser(prog="eksport", suggest_on_error=True, color=False)
    taklifli.add_argument("--format", choices=["json", "csv", "xlsx"])
    print(f"  {xato_ushla(taklifli, ['--format', 'jsn'])}")


if __name__ == "__main__":
    main()

=== 1. Standart xatolar (kod 2) ===
  (bo'sh)                    → kod 2: hisobot: error: the following arguments are required: fayl
  a --soni besh              → kod 2: hisobot: error: argument --soni: son kerak: 'besh'
  a --soni -3                → kod 2: hisobot: error: argument --soni: musbat son kerak: -3
  a --format xml             → kod 2: hisobot: error: argument --format: invalid choice: 'xml' (choose from 'json', 'csv')
  a --nomalum                → kod 2: hisobot: error: unrecognized arguments: --nomalum
  a --jim --batafsil         → kod 2: hisobot: error: argument --batafsil: not allowed with argument --jim
  a --boshi 17.09.2026       → kod 2: hisobot: error: argument --boshi: invalid fromisoformat value: '17.09.2026'

=== 2. ⚠️ type=bool ===
  --tozala False → True
  --tozala 0     → True
  BooleanOptionalAction: --tozala → True, --no-tozala → False, berilmasa → False

=== 3. Argumentlararo tekshiruv ===
  kod 2: hisobot: error: --oxiri (2026-09-01) --boshi (2026-09-30) dan oldin bo'lishi mumkin emas

=== 4. exit_on_error=False ===
  ArgumentError: argument --port: invalid int value: 'sakkiz' — dastur o'zi hal qiladi (masalan, veb-forma)

=== 5. parse_known_args ===
  ma'lum: soni=5, noma'lum: ['--pytest-bayroq', 'x']

=== 6. 3.14: suggest_on_error ===
  kod 2: eksport: error: argument --format: invalid choice: 'jsn', maybe you meant 'json'? (choose from 'json', 'csv', 'xlsx')

"""add_subparsers required; set_defaults bilan ishlovchi; parents bilan umumiy argumentlar; buyruqlarning o'z yordami; main(argv) -> int."""

import argparse
import contextlib
import io
import sys


def deploy(args: argparse.Namespace) -> int:
    print(f"  deploy: muhit={args.muhit}, versiya={args.versiya}, quruq={args.quruq}, verbose={args.verbose}")
    return 0


def qaytar(args: argparse.Namespace) -> int:
    if args.qadam > 3:
        print(f"  xato: {args.qadam} qadam orqaga — ko'pi bilan 3", file=sys.stderr)
        return 1
    print(f"  rollback: muhit={args.muhit}, qadam={args.qadam}")
    return 0


def holat(args: argparse.Namespace) -> int:
    print(f"  status: muhitlar={args.muhit or ['hammasi']}, format={args.format}")
    return 0


def parser_yarat() -> argparse.ArgumentParser:
    umumiy = argparse.ArgumentParser(add_help=False)
    umumiy.add_argument("-v", "--verbose", action="count", default=0)
    umumiy.add_argument("--quruq", action="store_true")

    asosiy = argparse.ArgumentParser(prog="relizchi", description="Relizlarni boshqarish", color=False)
    asosiy.add_argument("--version", action="version", version="%(prog)s 2.4.0")
    buyruqlar = asosiy.add_subparsers(dest="buyruq", required=True, metavar="BUYRUQ")

    d = buyruqlar.add_parser("deploy", parents=[umumiy], help="yangi versiyani joylashtirish", color=False)
    d.add_argument("muhit", choices=["staging", "prod"])
    d.add_argument("versiya")
    d.set_defaults(ishlovchi=deploy)

    r = buyruqlar.add_parser("rollback", parents=[umumiy], help="oldingi versiyaga qaytish", color=False)
    r.add_argument("muhit", choices=["staging", "prod"])
    r.add_argument("--qadam", type=int, default=1)
    r.set_defaults(ishlovchi=qaytar)

    s = buyruqlar.add_parser("status", parents=[umumiy], help="holatni ko'rsatish", color=False)
    s.add_argument("muhit", nargs="*")
    s.add_argument("--format", choices=["jadval", "json"], default="jadval")
    s.set_defaults(ishlovchi=holat)
    return asosiy


def main(argv: list[str] | None = None) -> int:
    args = parser_yarat().parse_args(argv)
    return args.ishlovchi(args)


def ishga_tushir(argv: list[str]) -> None:
    xato, chiqish = io.StringIO(), io.StringIO()
    with contextlib.redirect_stderr(xato), contextlib.redirect_stdout(chiqish):
        try:
            kod = main(argv)
        except SystemExit as s:
            kod = s.code
    print(f"$ relizchi {' '.join(argv)}")
    for qator in chiqish.getvalue().splitlines()[:12]:
        print(qator if qator.startswith("  ") else f"  {qator}")
    if xato.getvalue():
        print(f"  [stderr] {xato.getvalue().strip().splitlines()[-1]}")
    print(f"  → chiqish kodi {kod}\n")


def main_misol() -> None:
    for argv in (["deploy", "prod", "2.4.0", "-vv"], ["rollback", "prod", "--qadam", "5"], ["status", "staging", "prod", "--format", "json"],
                 [], ["deploy", "test", "2.4.0"], ["--version"], ["-h"]):
        ishga_tushir(argv)


if __name__ == "__main__":
    main_misol()

$ relizchi deploy prod 2.4.0 -vv
  deploy: muhit=prod, versiya=2.4.0, quruq=False, verbose=2
  → chiqish kodi 0

$ relizchi rollback prod --qadam 5
  [stderr] xato: 5 qadam orqaga — ko'pi bilan 3
  → chiqish kodi 1

$ relizchi status staging prod --format json
  status: muhitlar=['staging', 'prod'], format=json
  → chiqish kodi 0

$ relizchi
  [stderr] relizchi: error: the following arguments are required: BUYRUQ
  → chiqish kodi 2

$ relizchi deploy test 2.4.0
  [stderr] relizchi deploy: error: argument muhit: invalid choice: 'test' (choose from 'staging', 'prod')
  → chiqish kodi 2

$ relizchi --version
  relizchi 2.4.0
  → chiqish kodi 0

$ relizchi -h
  usage: relizchi [-h] [--version] BUYRUQ ...

  Relizlarni boshqarish

  positional arguments:
  BUYRUQ
    deploy    yangi versiyani joylashtirish
    rollback  oldingi versiyaga qaytish
    status    holatni ko'rsatish

  options:
  -h, --help  show this help message and exit
  → chiqish kodi 0

"""Ichki buyruqlar; muhitdan sukut; JSON saqlash va atomar yozish; ustuvorlik va muddat tekshiruvi; --json chiqish; FoydalanuvchiXatosi va chiqish kodlari; main(argv) sessiyasi."""

import argparse
import contextlib
import io
import json
import os
import sys
import tempfile
from datetime import date
from pathlib import Path


class FoydalanuvchiXatosi(Exception):
    pass


def ustuvorlik(qiymat: str) -> int:
    nomlar = {"past": 1, "orta": 2, "yuqori": 3}
    if qiymat not in nomlar:
        raise argparse.ArgumentTypeError(f"ustuvorlik {sorted(nomlar)} dan biri bo'lishi kerak")
    return nomlar[qiymat]


def yukla(fayl: Path) -> list[dict]:
    return json.loads(fayl.read_text(encoding="utf-8")) if fayl.exists() else []


def saqla(fayl: Path, vazifalar: list[dict]) -> None:
    vaqtinchalik = fayl.with_suffix(".tmp")
    vaqtinchalik.write_text(json.dumps(vazifalar, ensure_ascii=False, indent=1), encoding="utf-8")
    os.replace(vaqtinchalik, fayl)


def topish(vazifalar: list[dict], id_: int) -> dict:
    for v in vazifalar:
        if v["id"] == id_:
            return v
    raise FoydalanuvchiXatosi(f"{id_}-vazifa topilmadi")


def qosh(args: argparse.Namespace) -> int:
    vazifalar = yukla(args.fayl)
    if args.muddat and args.muddat < args.bugun:
        raise FoydalanuvchiXatosi(f"muddat o'tmishda: {args.muddat}")
    yangi = {"id": max((v["id"] for v in vazifalar), default=0) + 1, "matn": args.matn,
             "ustuvorlik": args.ustuvorlik, "muddat": args.muddat.isoformat() if args.muddat else None, "bajarildi": False}
    vazifalar.append(yangi)
    saqla(args.fayl, vazifalar)
    print(json.dumps(yangi, ensure_ascii=False) if args.json else f"qo'shildi: #{yangi['id']} {yangi['matn']}")
    return 0


def royxat(args: argparse.Namespace) -> int:
    vazifalar = [v for v in yukla(args.fayl) if args.hammasi or not v["bajarildi"]]
    vazifalar.sort(key=lambda v: (-v["ustuvorlik"], v["muddat"] or "9999", v["id"]))
    if args.json:
        print(json.dumps(vazifalar, ensure_ascii=False))
        return 0
    if not vazifalar:
        print("vazifalar yo'q")
    belgi = {1: "·", 2: "!", 3: "‼"}
    for v in vazifalar:
        holat = "✔" if v["bajarildi"] else " "
        muddat = f" (muddat: {v['muddat']})" if v["muddat"] else ""
        print(f"[{holat}] #{v['id']} {belgi[v['ustuvorlik']]} {v['matn']}{muddat}")
    return 0


def bajar(args: argparse.Namespace) -> int:
    vazifalar = yukla(args.fayl)
    for id_ in args.idlar:
        topish(vazifalar, id_)["bajarildi"] = True
    saqla(args.fayl, vazifalar)
    print(f"bajarildi: {', '.join(f'#{i}' for i in args.idlar)}")
    return 0


def ochir(args: argparse.Namespace) -> int:
    vazifalar = yukla(args.fayl)
    topish(vazifalar, args.id)
    if not args.tasdiq:
        raise FoydalanuvchiXatosi("o'chirish uchun --tasdiq bayrog'i kerak")
    saqla(args.fayl, [v for v in vazifalar if v["id"] != args.id])
    print(f"o'chirildi: #{args.id}")
    return 0


def parser_yarat(muhit: dict[str, str]) -> argparse.ArgumentParser:
    umumiy = argparse.ArgumentParser(add_help=False)
    umumiy.add_argument("--fayl", type=Path, default=Path(muhit.get("VAZIFA_FAYL", "vazifalar.json")))
    umumiy.add_argument("--json", action="store_true", help="mashina o'qiydigan chiqish")

    p = argparse.ArgumentParser(prog="vazifa", color=False)
    b = p.add_subparsers(dest="buyruq", required=True)
    q = b.add_parser("qosh", parents=[umumiy], color=False)
    q.add_argument("matn")
    q.add_argument("-u", "--ustuvorlik", type=ustuvorlik, default="orta")
    q.add_argument("--muddat", type=date.fromisoformat)
    q.set_defaults(ishlovchi=qosh)
    r = b.add_parser("royxat", parents=[umumiy], color=False)
    r.add_argument("-a", "--hammasi", action="store_true")
    r.set_defaults(ishlovchi=royxat)
    bj = b.add_parser("bajar", parents=[umumiy], color=False)
    bj.add_argument("idlar", type=int, nargs="+")
    bj.set_defaults(ishlovchi=bajar)
    o = b.add_parser("ochir", parents=[umumiy], color=False)
    o.add_argument("id", type=int)
    o.add_argument("--tasdiq", action="store_true")
    o.set_defaults(ishlovchi=ochir)
    return p


def main(argv: list[str] | None = None, muhit: dict[str, str] | None = None, bugun: date | None = None) -> int:
    muhit = dict(os.environ) if muhit is None else muhit
    args = parser_yarat(muhit).parse_args(argv)
    args.bugun = bugun or date.today()
    try:
        return args.ishlovchi(args)
    except FoydalanuvchiXatosi as xato:
        print(f"xato: {xato}", file=sys.stderr)
        return 1


def main_misol() -> None:
    with tempfile.TemporaryDirectory() as katalog:
        muhit = {"VAZIFA_FAYL": str(Path(katalog) / "vazifalar.json")}
        sessiya = [
            ["qosh", "15.15-darsni yozish", "-u", "yuqori", "--muddat", "2026-09-18"],
            ["qosh", "Zaxirani tekshirish", "-u", "past"],
            ["qosh", "Serverni yangilash", "--muddat", "2026-09-20"],
            ["qosh", "Eski vazifa", "--muddat", "2026-09-01"],
            ["qosh", "Noto'g'ri", "-u", "shoshilinch"],
            ["royxat"],
            ["bajar", "1", "3"],
            ["bajar", "9"],
            ["royxat", "--hammasi"],
            ["ochir", "2"],
            ["ochir", "2", "--tasdiq"],
            ["royxat", "--hammasi", "--json"],
        ]
        for argv in sessiya:
            chiqish, xato = io.StringIO(), io.StringIO()
            with contextlib.redirect_stdout(chiqish), contextlib.redirect_stderr(xato):
                try:
                    kod = main(argv, muhit, bugun=date(2026, 9, 17))
                except SystemExit as s:
                    kod = s.code
            print(f"$ vazifa {' '.join(argv)}")
            for qator in chiqish.getvalue().splitlines():
                print(f"  {qator}")
            if xato.getvalue():
                print(f"  [stderr] {xato.getvalue().strip().splitlines()[-1]}")
            print(f"  (kod {kod})")
        saqlangan = json.loads((Path(katalog) / "vazifalar.json").read_text(encoding="utf-8"))
        print(f"\nFaylda {len(saqlangan)} ta vazifa, .tmp qolmadi: {not (Path(katalog) / 'vazifalar.tmp').exists()}")


if __name__ == "__main__":
    main_misol()

$ vazifa qosh 15.15-darsni yozish -u yuqori --muddat 2026-09-18
  qo'shildi: #1 15.15-darsni yozish
  (kod 0)
$ vazifa qosh Zaxirani tekshirish -u past
  qo'shildi: #2 Zaxirani tekshirish
  (kod 0)
$ vazifa qosh Serverni yangilash --muddat 2026-09-20
  qo'shildi: #3 Serverni yangilash
  (kod 0)
$ vazifa qosh Eski vazifa --muddat 2026-09-01
  [stderr] xato: muddat o'tmishda: 2026-09-01
  (kod 1)
$ vazifa qosh Noto'g'ri -u shoshilinch
  [stderr] vazifa qosh: error: argument -u/--ustuvorlik: ustuvorlik ['orta', 'past', 'yuqori'] dan biri bo'lishi kerak
  (kod 2)
$ vazifa royxat
  [ ] #1 ‼ 15.15-darsni yozish (muddat: 2026-09-18)
  [ ] #3 ! Serverni yangilash (muddat: 2026-09-20)
  [ ] #2 · Zaxirani tekshirish
  (kod 0)
$ vazifa bajar 1 3
  bajarildi: #1, #3
  (kod 0)
$ vazifa bajar 9
  [stderr] xato: 9-vazifa topilmadi
  (kod 1)
$ vazifa royxat --hammasi
  [✔] #1 ‼ 15.15-darsni yozish (muddat: 2026-09-18)
  [✔] #3 ! Serverni yangilash (muddat: 2026-09-20)
  [ ] #2 · Zaxirani tekshirish
  (kod 0)
$ vazifa ochir 2
  [stderr] xato: o'chirish uchun --tasdiq bayrog'i kerak
  (kod 1)
$ vazifa ochir 2 --tasdiq
  o'chirildi: #2
  (kod 0)
$ vazifa royxat --hammasi --json
  [{"id": 1, "matn": "15.15-darsni yozish", "ustuvorlik": 3, "muddat": "2026-09-18", "bajarildi": true}, {"id": 3, "matn": "Serverni yangilash", "ustuvorlik": 2, "muddat": "2026-09-20", "bajarildi": true}]
  (kod 0)

Faylda 2 ta vazifa, .tmp qolmadi: True

p.add_argument("--tozala", type=bool)                     # ❌
p.add_argument("--tozala", action="store_true")           # ✅

if "--quruq" in sys.argv: ...                             # ❌ noma'lum argumentlar jim
args = p.parse_args()                                     # ✅

args = p.parse_args(); ... sys.exit(...)                  # ❌ modul darajasida
def main(argv=None) -> int: ...                           # ✅

if args.buyruq == "qosh": ... elif ...                    # ⚠️
buyruq.set_defaults(ishlovchi=qosh); args.ishlovchi(args) # ✅

args = p.parse_args()                                     # ⚠️ --oxiri < --boshi
if args.oxiri < args.boshi: p.error("...")                # ✅

argparse.ArgumentParser()                                 # ⚠️ usage da skript fayl nomi
argparse.ArgumentParser(prog="vazifa")                    # ✅

return args.ishlovchi(args)                               # ⚠️ KeyError traceback
except FoydalanuvchiXatosi as x: print(x, file=sys.stderr); return 1   # ✅

p.add_argument("--teg", action="append", default=["umumiy"])   # ⚠️ ["umumiy", "yangi"]

import argparse
p = argparse.ArgumentParser(prog="x")
p.add_argument("fayl")
p.add_argument("-n", type=int, default="3")
p.add_argument("-v", action="count", default=0)
p.add_argument("--teg", action="append", default=[])
p.add_argument("--rang", action=argparse.BooleanOptionalAction, default=True)
1.  print(p.parse_args(["a"]).n)
2.  print(type(p.parse_args(["a"]).n).__name__)
3.  print(p.parse_args(["a", "-vvv"]).v)
4.  print(p.parse_args(["a", "--teg", "x", "--teg", "y"]).teg)
5.  print(p.parse_args(["a", "--no-rang"]).rang)
6.  print(p.parse_args(["-n7", "a"]).n)
7.  print(p.parse_args(["--", "-a"]).fayl)
8.  print(vars(p.parse_args(["a"]))["fayl"])
9.  q = argparse.ArgumentParser(); q.add_argument("--d", type=bool)
    print(q.parse_args(["--d", ""]).d)
10. print(p.parse_known_args(["a", "--z"])[1])
11. try:
        p.parse_args([])
    except SystemExit as e:
        print(e.code)
12. print(bool("False"))

1.  p.add_argument("--quruq", type=bool, default=False)

2.  args = p.parse_args()
    if args.buyruq == "qosh": qosh(args)
    elif args.buyruq == "ochir": ochir(args)
    # buyruq berilmasa hech narsa bo'lmaydi

3.  import sys
    fayl = sys.argv[1]
    soni = int(sys.argv[2]) if len(sys.argv) > 2 else 10

4.  p.add_argument("--boshi"); p.add_argument("--oxiri")
    args = p.parse_args()
    hisobot(args.boshi, args.oxiri)          # "2026-09-30" > "2026-10-01" solishtirilmaydi

5.  args = argparse.ArgumentParser().parse_args()   # modul darajasida
    sys.exit(ishla(args))