15.13-dars: shutil va fayl amallari

shutil.rmtree(os.path.join(ZAXIRA_KATALOGI, eski_nom))

shutil.copytree(
    "loyiha", "zaxira/loyiha",
    ignore=shutil.ignore_patterns("__pycache__", "*.pyc", ".git"),
    dirs_exist_ok=True,        # maqsad mavjud bo'lsa ham
    copy_function=shutil.copy2,  # sukut
)

shutil.make_archive(base_name, format, root_dir=None, base_dir=None)
shutil.unpack_archive(fayl, maqsad, format=None, *, filter=None)

make_archive("zaxira", "zip", root_dir="loyiha")                  # ichida: src/..., README.md
make_archive("zaxira", "gztar", root_dir=".", base_dir="loyiha")  # ichida: loyiha/src/...

import shutil

shutil.copy2(manba, maqsad)                           # metama'lumot bilan
shutil.copytree(a, b, ignore=shutil.ignore_patterns("__pycache__", ".git"), dirs_exist_ok=True)
shutil.move(a, b)
shutil.rmtree(yol, onexc=ruxsatni_tuzat)              # xavfsizlik tekshiruvidan keyin!
arxiv = shutil.make_archive("zaxira-2026-09-17", "gztar", root_dir=ildiz)
shutil.unpack_archive(arxiv, vaqtinchalik_katalog)
shutil.disk_usage("/").free; shutil.which("git")

zaxira — copy2, copy emas
copytree maqsad mavjud — dirs_exist_ok=True
rmtree oldidan — yo'l tekshiruvi (bo'sh, ildiz, ruxsat etilgan katalog)
Windows faqat o'qiladigan fayllar — onexc
arxiv yo'llari — root_dir va base_dir
ishonchsiz arxiv — alohida katalog, hajm tekshiruvi
katta yozuv oldidan — disk_usage

"""copyfile, copy, copy2 va metama'lumot; katalogga nusxalash; copytree ignore va dirs_exist_ok; o'z ignore funksiyasi; move xulqi."""

import os
import shutil
import tempfile
from pathlib import Path

ESKI_VAQT = 1_700_000_000


def main() -> None:
    with tempfile.TemporaryDirectory() as vaqtinchalik:
        r = Path(vaqtinchalik)
        manba = r / "hisobot.txt"
        manba.write_text("2026-yil hisoboti", encoding="utf-8")
        os.utime(manba, (ESKI_VAQT, ESKI_VAQT))

        print("=== 1. Uch daraja ===")
        shutil.copyfile(manba, r / "copyfile.txt")
        shutil.copy(manba, r / "copy.txt")
        shutil.copy2(manba, r / "copy2.txt")
        for nom in ("copyfile.txt", "copy.txt", "copy2.txt"):
            yol = r / nom
            print(f"  {nom:13} mazmun bir xil: {yol.read_text(encoding='utf-8') == manba.read_text(encoding='utf-8')}, "
                  f"vaqt saqlandi: {yol.stat().st_mtime == ESKI_VAQT}")

        print("\n=== 2. Katalogga nusxalash ===")
        (r / "arxiv").mkdir()
        natija = shutil.copy2(manba, r / "arxiv")
        print(f"  copy2(fayl, katalog) → {Path(natija).relative_to(r).as_posix()}")
        try:
            shutil.copyfile(manba, r / "arxiv")
        except (IsADirectoryError, PermissionError) as xato:
            print(f"  copyfile(fayl, katalog) → {type(xato).__name__} (Linux'da IsADirectoryError)")

        print("\n=== 3. copytree ===")
        loyiha = r / "loyiha"
        for nisbiy in ("src/app.py", "src/__pycache__/app.cpython-314.pyc", ".git/HEAD", "README.md",
                       "data/katta.csv", "logs/bugun.log"):
            yol = loyiha / nisbiy
            yol.parent.mkdir(parents=True, exist_ok=True)
            yol.write_text("x" * (2000 if nisbiy.endswith(".csv") else 10), encoding="utf-8")

        shutil.copytree(loyiha, r / "zaxira", ignore=shutil.ignore_patterns("__pycache__", ".git", "*.log"))
        print(f"  ignore_patterns: {sorted(p.relative_to(r / 'zaxira').as_posix() for p in (r / 'zaxira').rglob('*') if p.is_file())}")

        def katta_fayllarsiz(katalog: str, nomlar: list[str]) -> set[str]:
            return {n for n in nomlar if os.path.isfile(os.path.join(katalog, n)) and os.path.getsize(os.path.join(katalog, n)) > 1000}

        shutil.copytree(loyiha, r / "yengil", ignore=katta_fayllarsiz)
        print(f"  o'z ignore funksiyasi (>1000 bayt): 'data/katta.csv' yo'q: {not (r / 'yengil' / 'data' / 'katta.csv').exists()}")
        try:
            shutil.copytree(loyiha, r / "zaxira")
        except FileExistsError:
            print("  qayta copytree → FileExistsError")
        shutil.copytree(loyiha, r / "zaxira", dirs_exist_ok=True, ignore=shutil.ignore_patterns(".git"))
        print(f"  dirs_exist_ok=True bilan yangilandi, logs qo'shildi: {(r / 'zaxira' / 'logs' / 'bugun.log').exists()}")

        print("\n=== 4. move ===")
        (r / "qabul").mkdir()
        yangi = shutil.move(r / "copy.txt", r / "qabul")
        print(f"  mavjud katalogga: {Path(yangi).relative_to(r).as_posix()}")
        yangi = shutil.move(r / "copyfile.txt", r / "qabul" / "nomi_ozgardi.txt")
        print(f"  yangi nom bilan:  {Path(yangi).relative_to(r).as_posix()}")
        yangi = shutil.move(r / "yengil", r / "qabul")
        print(f"  katalog:          {Path(yangi).relative_to(r).as_posix()}, ichida README: {(Path(yangi) / 'README.md').exists()}")


if __name__ == "__main__":
    main()

=== 1. Uch daraja ===
  copyfile.txt  mazmun bir xil: True, vaqt saqlandi: False
  copy.txt      mazmun bir xil: True, vaqt saqlandi: False
  copy2.txt     mazmun bir xil: True, vaqt saqlandi: True

=== 2. Katalogga nusxalash ===
  copy2(fayl, katalog) → arxiv/hisobot.txt
  copyfile(fayl, katalog) → PermissionError (Linux'da IsADirectoryError)

=== 3. copytree ===
  ignore_patterns: ['README.md', 'data/katta.csv', 'src/app.py']
  o'z ignore funksiyasi (>1000 bayt): 'data/katta.csv' yo'q: True
  qayta copytree → FileExistsError
  dirs_exist_ok=True bilan yangilandi, logs qo'shildi: True

=== 4. move ===
  mavjud katalogga: qabul/copy.txt
  yangi nom bilan:  qabul/nomi_ozgardi.txt
  katalog:          qabul/yengil, ichida README: True

"""Bo'sh yo'l bilan join tuzog'i; rmtree himoya funksiyasi; faqat o'qiladigan fayllar va onexc; ignore_errors xavfi."""

import os
import shutil
import stat
import tempfile
from pathlib import Path


class XavfliOchirish(Exception):
    pass


def xavfsiz_rmtree(yol: Path, ruxsat_ildizi: Path, nom_prefiksi: str) -> None:
    yol, ruxsat_ildizi = yol.resolve(), ruxsat_ildizi.resolve()
    if yol == ruxsat_ildizi:
        raise XavfliOchirish("ruxsat ildizining o'zini o'chirib bo'lmaydi")
    if yol == Path(yol.anchor) or yol == Path.home().resolve():
        raise XavfliOchirish(f"tizim katalogi: {yol}")
    if not yol.is_relative_to(ruxsat_ildizi):
        raise XavfliOchirish("ruxsat etilgan katalogdan tashqarida")
    if not yol.name.startswith(nom_prefiksi):
        raise XavfliOchirish(f"nom {nom_prefiksi!r} bilan boshlanmaydi: {yol.name!r}")

    def onexc(funksiya, xato_yoli, istisno):
        if isinstance(istisno, PermissionError):
            os.chmod(xato_yoli, stat.S_IWRITE)
            funksiya(xato_yoli)
        else:
            raise istisno

    shutil.rmtree(yol, onexc=onexc)


def main() -> None:
    with tempfile.TemporaryDirectory() as vaqtinchalik:
        zaxiralar = Path(vaqtinchalik) / "zaxiralar"
        for nom in ("zaxira-2026-09-15", "zaxira-2026-09-16", "muhim-hujjatlar"):
            (zaxiralar / nom).mkdir(parents=True)
            (zaxiralar / nom / "fayl.txt").write_text(nom, encoding="utf-8")

        print("=== 1. ⚠️ Bo'sh nom bilan join ===")
        eski_nom = ""
        print(f"  os.path.join(zaxiralar, '') ildizning o'zi: {Path(os.path.join(zaxiralar, eski_nom)).resolve() == zaxiralar.resolve()}")
        print(f"  Path(zaxiralar) / '' ham: {(zaxiralar / eski_nom).resolve() == zaxiralar.resolve()}")

        print("\n=== 2. Himoya tekshiruvlari ===")
        sinovlar = [("bo'sh nom", zaxiralar / ""), ("boshqa katalog", zaxiralar / "muhim-hujjatlar"),
                    ("tashqariga ..", zaxiralar / ".." / ".."), ("to'g'ri", zaxiralar / "zaxira-2026-09-15")]
        for tavsif, yol in sinovlar:
            try:
                xavfsiz_rmtree(yol, zaxiralar, "zaxira-")
                print(f"  {tavsif:14} → o'chirildi")
            except XavfliOchirish as xato:
                print(f"  {tavsif:14} → rad: {xato}")
        print(f"  qolganlar: {sorted(p.name for p in zaxiralar.iterdir())}")

        print("\n=== 3. ⚠️ Faqat o'qiladigan fayllar ===")
        git = Path(vaqtinchalik) / "klon" / ".git" / "objects"
        git.mkdir(parents=True)
        obyekt = git / "ab12"
        obyekt.write_bytes(b"blob")
        obyekt.chmod(stat.S_IREAD)
        try:
            shutil.rmtree(Path(vaqtinchalik) / "klon")
            print("  oddiy rmtree o'chirdi (Linux/macOS'da ota katalog ruxsati yetarli)")
        except PermissionError:
            print("  oddiy rmtree → PermissionError (Windows)")
        shutil.rmtree(Path(vaqtinchalik) / "klon", ignore_errors=True)
        print(f"  ignore_errors=True dan keyin katalog hali ham bor: {(Path(vaqtinchalik) / 'klon').exists()}  ← jim yarim natija")
        if (Path(vaqtinchalik) / "klon").exists():
            (Path(vaqtinchalik) / "klon").rename(zaxiralar / "zaxira-klon")
            xavfsiz_rmtree(zaxiralar / "zaxira-klon", zaxiralar, "zaxira-")
        print(f"  onexc bilan to'liq o'chirildi: {not (zaxiralar / 'zaxira-klon').exists()}")


if __name__ == "__main__":
    main()

=== 1. ⚠️ Bo'sh nom bilan join ===
  os.path.join(zaxiralar, '') ildizning o'zi: True
  Path(zaxiralar) / '' ham: True

=== 2. Himoya tekshiruvlari ===
  bo'sh nom      → rad: ruxsat ildizining o'zini o'chirib bo'lmaydi
  boshqa katalog → rad: nom 'zaxira-' bilan boshlanmaydi: 'muhim-hujjatlar'
  tashqariga ..  → rad: ruxsat etilgan katalogdan tashqarida
  to'g'ri        → o'chirildi
  qolganlar: ['muhim-hujjatlar', 'zaxira-2026-09-16']

=== 3. ⚠️ Faqat o'qiladigan fayllar ===
  oddiy rmtree → PermissionError (Windows)
  ignore_errors=True dan keyin katalog hali ham bor: True  ← jim yarim natija
  onexc bilan to'liq o'chirildi: True

"""make_archive: root_dir va base_dir farqi; formatlar; unpack_archive; zip slip — jim o'tkazish; tar filtri 3.14; hajm tekshiruvi; disk_usage, which, terminal o'lchami."""

import io
import shutil
import tarfile
import tempfile
import zipfile
from pathlib import Path


def ichidagilar(arxiv: str) -> list[str]:
    if arxiv.endswith(".zip"):
        with zipfile.ZipFile(arxiv) as z:
            return sorted(z.namelist())
    with tarfile.open(arxiv) as t:
        return sorted(t.getnames())


def main() -> None:
    with tempfile.TemporaryDirectory() as vaqtinchalik:
        r = Path(vaqtinchalik)
        loyiha = r / "loyiha"
        (loyiha / "src").mkdir(parents=True)
        (loyiha / "src" / "app.py").write_text("print(1)\n", encoding="utf-8")
        (loyiha / "README.md").write_text("# Loyiha\n", encoding="utf-8")

        print("=== 1. root_dir va base_dir ===")
        a = shutil.make_archive(str(r / "faqat_ichi"), "zip", root_dir=loyiha)
        b = shutil.make_archive(str(r / "katalog_bilan"), "gztar", root_dir=r, base_dir="loyiha")
        print(f"  {Path(a).name:24} {ichidagilar(a)}")
        print(f"  {Path(b).name:24} {[n for n in ichidagilar(b) if n.endswith(('.py', '.md'))]}")
        print(f"  formatlar: {sorted(nom for nom, _ in shutil.get_archive_formats())}")

        print("\n=== 2. Ochish ===")
        shutil.unpack_archive(a, r / "ochildi")
        print(f"  {sorted(p.relative_to(r / 'ochildi').as_posix() for p in (r / 'ochildi').rglob('*') if p.is_file())}")

        print("\n=== 3. ⚠️ Zip slip ===")
        yomon_zip = r / "yomon.zip"
        with zipfile.ZipFile(yomon_zip, "w") as z:
            z.writestr("rasm.png", b"png")
            z.writestr("../../tashqari.txt", b"hujum")
        print(f"  arxiv ichida: {ichidagilar(str(yomon_zip))}")
        shutil.unpack_archive(yomon_zip, r / "zip_ochildi")
        print(f"  unpack_archive: xavfsiz fayl ochildi: {(r / 'zip_ochildi' / 'rasm.png').exists()}, "
              f"tashqariga yozilmadi: {not (r.parent / 'tashqari.txt').exists() and not (r / 'tashqari.txt').exists()}")
        print("  ⚠️ xavfli nom jim o'tkazib yuborildi — xabar yo'q")

        print("\n=== 4. ⭐ tar filtri (3.14 sukuti 'data') ===")
        yomon_tar = r / "yomon.tar"
        with tarfile.open(yomon_tar, "w") as t:
            malumot = b"hujum"
            info = tarfile.TarInfo("../tashqari2.txt")
            info.size = len(malumot)
            t.addfile(info, io.BytesIO(malumot))
        try:
            shutil.unpack_archive(yomon_tar, r / "tar_ochildi")
        except tarfile.OutsideDestinationError as xato:
            print(f"  {type(xato).__name__}: '{xato.tarinfo.name}' maqsaddan tashqarida")

        print("\n=== 5. Hajm tekshiruvi (zip bomb) ===")
        bomba = r / "bomba.zip"
        with zipfile.ZipFile(bomba, "w", compression=zipfile.ZIP_DEFLATED) as z:
            z.writestr("nol.bin", b"\x00" * 20_000_000)
        with zipfile.ZipFile(bomba) as z:
            ochilgan = sum(i.file_size for i in z.infolist())
        siqilgan = bomba.stat().st_size
        print(f"  arxiv hajmi 100 KB dan kam: {siqilgan < 100_000}, ochilganda 20 MB: {ochilgan == 20_000_000}")
        print(f"  siqish nisbati 200 dan katta: {ochilgan / siqilgan > 200}  → ochishdan oldin rad etish kerak")

        print("\n=== 6. Tizim yordamchilari ===")
        joy = shutil.disk_usage(r)
        print(f"  disk_usage: total > used > 0: {joy.total > joy.used > 0}, free > 0: {joy.free > 0}")
        print(f"  which('python') yoki which('py') topildi: {bool(shutil.which('python') or shutil.which('py'))}")
        print(f"  which('bunday-dastur-yoq'): {shutil.which('bunday-dastur-yoq')}")
        print(f"  get_terminal_size((80, 24)) turi: {type(shutil.get_terminal_size((80, 24))).__name__}")


if __name__ == "__main__":
    main()

=== 1. root_dir va base_dir ===
  faqat_ichi.zip           ['README.md', 'src/', 'src/app.py']
  katalog_bilan.tar.gz     ['loyiha/README.md', 'loyiha/src/app.py']
  formatlar: ['bztar', 'gztar', 'tar', 'xztar', 'zip', 'zstdtar']

=== 2. Ochish ===
  ['README.md', 'src/app.py']

=== 3. ⚠️ Zip slip ===
  arxiv ichida: ['../../tashqari.txt', 'rasm.png']
  unpack_archive: xavfsiz fayl ochildi: True, tashqariga yozilmadi: True
  ⚠️ xavfli nom jim o'tkazib yuborildi — xabar yo'q

=== 4. ⭐ tar filtri (3.14 sukuti 'data') ===
  OutsideDestinationError: '../tashqari2.txt' maqsaddan tashqarida

=== 5. Hajm tekshiruvi (zip bomb) ===
  arxiv hajmi 100 KB dan kam: True, ochilganda 20 MB: True
  siqish nisbati 200 dan katta: True  → ochishdan oldin rad etish kerak

=== 6. Tizim yordamchilari ===
  disk_usage: total > used > 0: True, free > 0: True
  which('python') yoki which('py') topildi: True
  which('bunday-dastur-yoq'): None
  get_terminal_size((80, 24)) turi: terminal_size

"""copytree ignore bilan tayyorlash; make_archive vaqt belgili nom; disk_usage tekshiruvi; vaqtinchalik nom + os.replace; ochib xesh bilan tekshirish; aylanish va himoyalangan o'chirish."""

import hashlib
import os
import shutil
import tempfile
from datetime import UTC, datetime, timedelta
from pathlib import Path

PREFIKS = "zaxira-"
OTKAZ = shutil.ignore_patterns("__pycache__", ".git", "*.log", "node_modules")


def xeshlar(ildiz: Path) -> dict[str, str]:
    return {p.relative_to(ildiz).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest()
            for p in sorted(ildiz.rglob("*")) if p.is_file()}


def zaxira_ol(loyiha: Path, zaxiralar: Path, hozir: datetime, saqlash: int, min_bosh_joy: int) -> dict[str, object]:
    zaxiralar.mkdir(parents=True, exist_ok=True)
    nom = f"{PREFIKS}{hozir:%Y%m%d-%H%M%S}"
    if shutil.disk_usage(zaxiralar).free < min_bosh_joy:
        raise OSError("diskda joy yetarli emas")

    with tempfile.TemporaryDirectory() as ish:
        tayyor = Path(ish) / "loyiha"
        shutil.copytree(loyiha, tayyor, ignore=OTKAZ)
        asl = xeshlar(tayyor)
        vaqtinchalik = shutil.make_archive(str(Path(ish) / nom), "gztar", root_dir=tayyor)

        tekshiruv = Path(ish) / "tekshiruv"
        shutil.unpack_archive(vaqtinchalik, tekshiruv)
        if xeshlar(tekshiruv) != asl:
            raise RuntimeError("arxiv mazmuni mos kelmadi")

        yakuniy = zaxiralar / Path(vaqtinchalik).name
        shutil.copy2(vaqtinchalik, zaxiralar / (yakuniy.name + ".tmp"))
        os.replace(zaxiralar / (yakuniy.name + ".tmp"), yakuniy)

    mavjud = sorted(p for p in zaxiralar.iterdir() if p.name.startswith(PREFIKS) and p.name.endswith(".tar.gz"))
    ochirilgan = []
    for eski in mavjud[:-saqlash]:
        yol = eski.resolve()
        if yol.parent == zaxiralar.resolve() and yol.name.startswith(PREFIKS):
            yol.unlink()
            ochirilgan.append(yol.name)
    return {"arxiv": yakuniy.name, "fayllar": len(asl), "ochirilgan": ochirilgan}


def main() -> None:
    with tempfile.TemporaryDirectory() as vaqtinchalik:
        r = Path(vaqtinchalik)
        loyiha, zaxiralar = r / "loyiha", r / "zaxiralar"
        for nisbiy, mazmun in {"src/app.py": "v1", "src/__pycache__/app.pyc": "kesh", "README.md": "# L",
                               "server.log": "log", ".git/HEAD": "ref"}.items():
            (loyiha / nisbiy).parent.mkdir(parents=True, exist_ok=True)
            (loyiha / nisbiy).write_text(mazmun, encoding="utf-8")
        (zaxiralar / "muhim.txt").parent.mkdir(parents=True)
        (zaxiralar / "muhim.txt").write_text("boshqa fayl — tegmaslik kerak", encoding="utf-8")

        print("=== 1. Besh kunlik zaxira, oxirgi 3 tasi saqlanadi ===")
        boshlanish = datetime(2026, 9, 13, 2, 0, tzinfo=UTC)
        for kun in range(5):
            (loyiha / "src" / "app.py").write_text(f"v{kun + 1}", encoding="utf-8")
            natija = zaxira_ol(loyiha, zaxiralar, boshlanish + timedelta(days=kun), saqlash=3, min_bosh_joy=1024)
            print(f"  {natija['arxiv']}  fayllar={natija['fayllar']}  o'chirildi={natija['ochirilgan']}")

        print("\n=== 2. Holat ===")
        print(f"  zaxiralar katalogi: {sorted(p.name for p in zaxiralar.iterdir())}")
        print(f"  .tmp qolmadi: {not any(p.suffix == '.tmp' for p in zaxiralar.iterdir())}")
        print(f"  begona fayl saqlandi: {(zaxiralar / 'muhim.txt').exists()}")

        print("\n=== 3. Eng oxirgi zaxirani tiklash ===")
        oxirgi = sorted(zaxiralar.glob(f"{PREFIKS}*.tar.gz"))[-1]
        tiklash = r / "tiklandi"
        shutil.unpack_archive(oxirgi, tiklash)
        print(f"  tiklangan fayllar: {sorted(xeshlar(tiklash))}")
        print(f"  app.py oxirgi versiya: {(tiklash / 'src' / 'app.py').read_text(encoding='utf-8')!r}")
        print(f"  keraksizlar kirmadi (__pycache__, .git, *.log): {not any(k in s for s in xeshlar(tiklash) for k in ('__pycache__', '.git', '.log'))}")

        print("\n=== 4. Diskda joy yetmasa ===")
        try:
            zaxira_ol(loyiha, zaxiralar, boshlanish + timedelta(days=10), saqlash=3, min_bosh_joy=10**18)
        except OSError as xato:
            print(f"  OSError: {xato} — mavjud zaxiralar tegilmadi: {len(list(zaxiralar.glob(PREFIKS + '*')))} ta")


if __name__ == "__main__":
    main()

=== 1. Besh kunlik zaxira, oxirgi 3 tasi saqlanadi ===
  zaxira-20260913-020000.tar.gz  fayllar=2  o'chirildi=[]
  zaxira-20260914-020000.tar.gz  fayllar=2  o'chirildi=[]
  zaxira-20260915-020000.tar.gz  fayllar=2  o'chirildi=[]
  zaxira-20260916-020000.tar.gz  fayllar=2  o'chirildi=['zaxira-20260913-020000.tar.gz']
  zaxira-20260917-020000.tar.gz  fayllar=2  o'chirildi=['zaxira-20260914-020000.tar.gz']

=== 2. Holat ===
  zaxiralar katalogi: ['muhim.txt', 'zaxira-20260915-020000.tar.gz', 'zaxira-20260916-020000.tar.gz', 'zaxira-20260917-020000.tar.gz']
  .tmp qolmadi: True
  begona fayl saqlandi: True

=== 3. Eng oxirgi zaxirani tiklash ===
  tiklangan fayllar: ['README.md', 'src/app.py']
  app.py oxirgi versiya: 'v5'
  keraksizlar kirmadi (__pycache__, .git, *.log): True

=== 4. Diskda joy yetmasa ===
  OSError: diskda joy yetarli emas — mavjud zaxiralar tegilmadi: 3 ta

shutil.rmtree(os.path.join(ZAXIRA, nom))    # ❌ nom="" — hammasi
xavfsiz_rmtree(ZAXIRA / nom, ZAXIRA, "zaxira-")   # ✅

shutil.copy(manba, zaxira)                  # ⚠️ vaqt yo'qoladi
shutil.copy2(manba, zaxira)                 # ✅

shutil.make_archive(...)                    # ⚠️ disk to'lsa — yaroqsiz arxiv
if shutil.disk_usage(katalog).free < kerak: raise OSError(...)   # ✅

shutil.make_archive(ZAXIRA / nom, ...)      # ⚠️ uzilsa — buzilgan "yangi" zaxira
# ✅ vaqtinchalik joyda yaratish, ochib tekshirish, os.replace

shutil.unpack_archive(yuklangan, "/srv/app")   # ❌
# ✅ vaqtinchalik katalog + hajm tekshiruvi + kerakli fayllarni ko'chirish

tarfile.open(f).extractall(maqsad, filter="fully_trusted")   # ❌ ishonchsiz arxivda

subprocess.run([shutil.which("ffmpeg"), ...])   # ❌ None → TypeError
if (ffmpeg := shutil.which("ffmpeg")) is None: sys.exit("ffmpeg o'rnatilmagan")   # ✅

shutil.copytree(loyiha, zaxira)             # ⚠️ node_modules, .git, loglar
shutil.copytree(loyiha, zaxira, ignore=shutil.ignore_patterns(...))   # ✅

import shutil, os
1.  print(os.path.join("zaxira", "") in ("zaxira/", "zaxira\\"))
2.  print(shutil.which("bunday_dastur_yoq_123"))
3.  print(type(shutil.disk_usage(".")).__name__)
4.  print(shutil.get_terminal_size((100, 30)).columns >= 1)
5.  print("zip" in [n for n, _ in shutil.get_archive_formats()])
6.  print("zstdtar" in [n for n, _ in shutil.get_archive_formats()])
7.  print(callable(shutil.ignore_patterns("*.pyc")))
8.  print(shutil.ignore_patterns("*.pyc")(".", ["a.py", "b.pyc", "c.pyc"]))
9.  print(hasattr(shutil, "copy2"))
10. print(shutil.disk_usage(".").free <= shutil.disk_usage(".").total)
11. print(issubclass(FileExistsError, OSError))
12. print(sorted(shutil.ignore_patterns("__pycache__", "*.log")(".", ["__pycache__", "x.log", "y.txt"])))

1.  def tozala(eski_nom):
        shutil.rmtree(os.path.join("/srv/zaxiralar", eski_nom))

2.  def sinxronla(manba, maqsad):
        shutil.copytree(manba, maqsad)          # har kuni ishga tushadi

3.  def arxivla(katalog):
        return shutil.make_archive("/srv/zaxira/oxirgi", "zip", katalog)

4.  def ochish(yuklangan_zip):
        shutil.unpack_archive(yuklangan_zip, "/srv/app/plugins")

5.  def video_siq(fayl):
        subprocess.run([shutil.which("ffmpeg"), "-i", fayl, "chiqish.mp4"])