Python kursi18.6-dars: pre-commit
Python kursi · Sifat va vositalar

18.6-dars: pre-commit

19 daqiqa6/8-dars

18-QISM — SIFAT VA VOSITALAR · 6-dars


1. Kirish va motivatsiya

O'tgan darslarda ruff (lint) va black (format) ni o'rgandik. Ular ajoyib, lekin bitta muammo bor: ularni ishga tushirishni unutish mumkin. Dasturchi shoshib, formatlanmagan yoki muammoli kodni commit qiladi, va u repozitoriyga tushadi. Yechim — pre-commit: har commit'dan oldin tekshiruvlarni avtomatik ishga tushiradigan mexanizm. Agar tekshiruv o'tmasa, commit bloklanadi.

pre-commit — sifat vositalarini (lint, format, test) git ish oqimiga singdiradi: muammoli kod repozitoriyga umuman tusha olmaydi.

Real vaziyat. Bir jamoa ruff va black ni sozlagan edi, lekin ular qo'lda ishga tushirilardi. Natijada: kimdir formatlashni unutar, kimdir lint xatosini e'tiborsiz qoldirar, va CI (28-qism) da bu muammolar topilib, qurilish yiqilardi — bu vaqt isrofi edi. Ular pre-commit qo'shishdi: endi har git commit da avtomatik ruff va black ishga tushadi. Formatlanmagan kod commit qilinmaydi — pre-commit uni to'xtatadi va (ko'pincha) o'zi tuzatadi. Muammolar commit'dan oldin hal bo'ladi, CI ga yetmasdan. Kod bazasi doim toza qoldi.

Bu darsda pre-commit bilan tekshiruvlarni avtomatlashtirishni o'rganamiz.

Bu darsda:

  • Git hook'lar va pre-commit nima
  • .pre-commit-config.yaml — sozlash
  • Hook commit'ni qanday bloklaydi
  • Keng tarqalgan hook'lar (ruff, black, va h.k.)
  • O'rnatish va ishga tushirish
  • Hook'larni chetlab o'tish (--no-verify)
  • CI bilan bog'liqlik
  • Amaliy: to'liq hook sozlash

ℹ pre-commit — tashqi vosita (pip install pre-commit). Misollarda git hook'lar mexanizmi git va subprocess bilan ko'rsatiladi.


2. Nazariya — chuqur tushuntirish

2.1. Git hook'lar

Git hook — muayyan git hodisasida avtomatik ishga tushadigan skript:

Hook Qachon ishlaydi
pre-commit Commit'dan oldin (eng ko'p ishlatiladi)
commit-msg Commit xabari yozilgach
pre-push Push'dan oldin
post-merge Merge'dan keyin

pre-commit hook — commit yaratilishidan oldin ishlaydi va nol bo'lmagan chiqish kodi qaytarsa, commit bekor qilinadi.

2.2. pre-commit vositasi

Xom git hook'larni yozish qiyin (har dasturchi qo'lda o'rnatishi kerak). pre-commit (vosita) buni soddalashtiradi: hook'larni .pre-commit-config.yaml da e'lon qilasiz, u ularni o'rnatadi va boshqaradi:

bash
pip install pre-commit
pre-commit install             # git hook'ni o'rnatadi
pre-commit run --all-files     # barcha faylda qo'lda ishga tushirish

.pre-commit-config.yaml git'ga qo'shiladi — butun jamoa bir xil hook'larni oladi.

2.3. .pre-commit-config.yaml

yaml
repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.6.0
    hooks:
      - id: ruff              # lint
        args: [--fix]
      - id: ruff-format       # format

  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
Maydon Ma'nosi
repo Hook manbai (git repozitoriy)
rev Versiya (qulflash — takrorlanuvchanlik)
hooks Ishga tushadigan hook'lar
args Hook argumentlari

2.4. Hook commit'ni qanday bloklaydi

git commit
   ↓
pre-commit hook ishga tushadi
   ↓
ruff/black tekshiradi
   ↓
├── ✅ o'tdi → commit yaratiladi
└── ❌ yiqildi → commit BEKOR (xato ko'rsatiladi)

Ko'p hook (ruff, black) muammoni o'zi tuzatadi va faylni o'zgartiradi — keyin siz tuzatilgan faylni qayta git add qilib, commit qilasiz.

2.5. Keng tarqalgan hook'lar

Hook Nima qiladi
ruff Lint (18.4)
ruff-format / black Format (18.5)
trailing-whitespace Qator oxiridagi bo'shliqni olib tashlaydi
end-of-file-fixer Fayl oxirida bitta yangi qator
check-yaml/check-toml YAML/TOML sintaksisini tekshiradi
check-added-large-files Katta fayllarni bloklaydi
detect-private-key Maxfiy kalitlarni topadi
mypy Tur tekshiruvi (13-qism)

detect-private-key va check-added-large-files — xavfsizlik: sirlar va katta fayllar repozitoriyga tushishining oldini oladi.

2.6. O'rnatish va ishga tushirish

bash
pre-commit install             # hook'ni git'ga o'rnatadi (bir marta)
git commit                     # endi hook avtomatik ishlaydi
pre-commit run --all-files     # barcha faylda qo'lda (birinchi marta foydali)
pre-commit autoupdate          # hook versiyalarini yangilaydi

pre-commit install — har dasturchi loyihani klon qilgach bir marta bajarishi kerak (yoki avtomatlashtirilgan).

2.7. Hook'larni chetlab o'tish

Ba'zan (favqulodda) hook'ni o'tkazib yuborish kerak:

bash
git commit --no-verify         # hook'larsiz commit (ehtiyot bo'ling!)

--no-verify — faqat haqiqiy favqulodda holatda. Muntazam ishlatish pre-commit ning butun maqsadini yo'qqa chiqaradi. Muammoni chetlab o'tish emas, hal qilish kerak.

2.8. pre-commit va CI

Qatlam Rol
pre-commit (mahalliy) Commit'dan oldin — tez qaytar aloqa
CI (28-qism) Push/PR'dan keyin — kafolat

Ikkalasi to'ldiradi: pre-commit muammolarni erta (mahalliy) ushlaydi, CI esa kafolat beradi (kimdir --no-verify ishlatsa ham). CI da ham bir xil tekshiruvlar (ruff check, black --check) ishga tushiriladi.


3. Tez ma'lumotnoma

bash
pip install pre-commit
pre-commit install             # o'rnatish (bir marta)
pre-commit run --all-files     # qo'lda ishga tushirish
pre-commit autoupdate          # yangilash
git commit --no-verify         # chetlab o'tish (ehtiyot!)
yaml
# .pre-commit-config.yaml
repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.6.0
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format

Qoidalar

pre-commit — commit'dan oldin avtomatik tekshiruv
.pre-commit-config.yaml git'ga qo'shiladi
rev bilan hook versiyasini qulflang
muammoli kod commit qilinmaydi (bloklanadi)
--no-verify faqat favqulodda holatda
pre-commit (mahalliy) + CI (kafolat) birga

4. Batafsil misollar

Misollarda git hook mexanizmi vaqtinchalik git repozitoriyda ko'rsatiladi; pre-commit config tuzilishi yaml bilan tahlil qilinadi.

Misol 1 — .pre-commit-config.yaml tuzilishi

python
"""pre-commit config (YAML): repos, rev, hooks, args; tahlil; versiya qulflash muhimligi; keng tarqalgan hook'lar."""

import yaml

CONFIG = """
repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.6.0
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format

  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: detect-private-key
"""


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

    print("=== 1. Hook manbalari (repos) ===")
    for repo in d["repos"]:
        nom = repo["repo"].split("/")[-1]
        print(f"  {nom} (rev: {repo['rev']}) — {len(repo['hooks'])} hook")

    print("\n=== 2. Barcha hook'lar ===")
    for repo in d["repos"]:
        for hook in repo["hooks"]:
            args = f" args={hook['args']}" if "args" in hook else ""
            print(f"  {hook['id']}{args}")

    print("\n=== 3. Versiya qulflash (rev) ===")
    for repo in d["repos"]:
        print(f"  {repo['repo'].split('/')[-1]}: {repo['rev']}")
    print("  ⭐ rev — hook versiyasini qulflaydi (takrorlanuvchanlik, 18.2 g'oyasi)")

    print("\n=== 4. Hook turlari ===")
    turlar = {
        "ruff": "lint (muammolar)",
        "ruff-format": "format (ko'rinish)",
        "trailing-whitespace": "qator oxiri bo'shliq",
        "end-of-file-fixer": "fayl oxiri yangi qator",
        "check-yaml": "YAML sintaksisi",
        "detect-private-key": "⚠️ maxfiy kalitlarni topadi (xavfsizlik)",
    }
    for repo in d["repos"]:
        for hook in repo["hooks"]:
            if hook["id"] in turlar:
                print(f"  {hook['id']:22} → {turlar[hook['id']]}")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Hook manbalari (repos) ===
  ruff-pre-commit (rev: v0.6.0) — 2 hook
  pre-commit-hooks (rev: v4.6.0) — 4 hook

=== 2. Barcha hook'lar ===
  ruff args=['--fix']
  ruff-format
  trailing-whitespace
  end-of-file-fixer
  check-yaml
  detect-private-key

=== 3. Versiya qulflash (rev) ===
  ruff-pre-commit: v0.6.0
  pre-commit-hooks: v4.6.0
  ⭐ rev — hook versiyasini qulflaydi (takrorlanuvchanlik, 18.2 g'oyasi)

=== 4. Hook turlari ===
  ruff                   → lint (muammolar)
  ruff-format            → format (ko'rinish)
  trailing-whitespace    → qator oxiri bo'shliq
  end-of-file-fixer      → fayl oxiri yangi qator
  check-yaml             → YAML sintaksisi
  detect-private-key     → ⚠️ maxfiy kalitlarni topadi (xavfsizlik)

Nima ko'rsatdi: 2.3, 2.5-bo'limlar.

Misol 2 — Git hook commit'ni bloklaydi

python
"""git pre-commit hook mexanizmi: muammoli kod commit'ni bloklaydi (ruff yiqiladi); vaqtinchalik git repozitoriyda haqiqiy namoyish."""

import shutil
import subprocess
import sys
import tempfile
from pathlib import Path


def ruff_yol() -> str:
    yol = shutil.which("ruff")
    if yol:
        return yol
    bin_papka = "Scripts" if sys.platform == "win32" else "bin"
    return str(Path(sys.executable).parent / bin_papka / ("ruff.exe" if sys.platform == "win32" else "ruff"))


def git(katalog: Path, *args: str):
    return subprocess.run(["git", "-C", str(katalog), *args], capture_output=True, text=True, encoding="utf-8")


def main() -> None:
    with tempfile.TemporaryDirectory() as katalog:
        r = Path(katalog)
        git(r, "init")
        git(r, "config", "user.email", "test@wisar.uz")
        git(r, "config", "user.name", "Test")

        # pre-commit hook: staged .py fayllarni ruff bilan tekshiradi
        hook = r / ".git" / "hooks" / "pre-commit"
        hook.write_text(
            f'#!/bin/sh\n'
            f'files=$(git diff --cached --name-only --diff-filter=ACM | grep "\\.py$")\n'
            f'[ -z "$files" ] && exit 0\n'
            f'"{ruff_yol()}" check --no-cache --select F,E $files\n',
            encoding="utf-8")
        hook.chmod(0o755)

        print("=== 1. Muammoli kod (ishlatilmagan import) ===")
        (r / "kod.py").write_text("import os\nx = 1\n", encoding="utf-8")
        git(r, "add", "kod.py")
        natija = git(r, "commit", "-m", "muammoli commit")
        print(f"  commit chiqish kodi: {natija.returncode} (0 emas — bloklandi)")
        log = git(r, "log", "--oneline")
        print(f"  git log bo'sh (commit yaratilmadi): {log.stdout.strip() == ''}")
        print("  ⭐ pre-commit hook F401 xatosini topib, commit'ni to'xtatdi")

        print("\n=== 2. Kod tuzatilgach ===")
        (r / "kod.py").write_text("x = 1\n", encoding="utf-8")   # ishlatilmagan import olib tashlandi
        git(r, "add", "kod.py")
        natija = git(r, "commit", "-m", "toza commit")
        print(f"  commit chiqish kodi: {natija.returncode} (0 — muvaffaqiyat)")
        log = git(r, "log", "--oneline")
        print(f"  commit yaratildi: {log.stdout.strip() != ''}")
        print("  ⭐ toza kod hook'dan o'tdi va commit qilindi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Muammoli kod (ishlatilmagan import) ===
  commit chiqish kodi: 1 (0 emas — bloklandi)
  git log bo'sh (commit yaratilmadi): True
  ⭐ pre-commit hook F401 xatosini topib, commit'ni to'xtatdi

=== 2. Kod tuzatilgach ===
  commit chiqish kodi: 0 (0 — muvaffaqiyat)
  commit yaratildi: True
  ⭐ toza kod hook'dan o'tdi va commit qilindi

Nima ko'rsatdi: 2.1, 2.4-bo'limlar.

Misol 3 — Hook o'zi tuzatadi va --no-verify

python
"""hook faylni avtomatik tuzatadi (ruff --fix); tuzatilgan faylni qayta add qilish kerak; --no-verify hook'ni chetlab o'tadi (ehtiyot)."""

import shutil
import subprocess
import sys
import tempfile
from pathlib import Path


def ruff_yol() -> str:
    yol = shutil.which("ruff")
    if yol:
        return yol
    bin_papka = "Scripts" if sys.platform == "win32" else "bin"
    return str(Path(sys.executable).parent / bin_papka / ("ruff.exe" if sys.platform == "win32" else "ruff"))


def git(katalog: Path, *args: str):
    return subprocess.run(["git", "-C", str(katalog), *args], capture_output=True, text=True, encoding="utf-8")


def main() -> None:
    with tempfile.TemporaryDirectory() as katalog:
        r = Path(katalog)
        git(r, "init")
        git(r, "config", "user.email", "test@wisar.uz")
        git(r, "config", "user.name", "Test")

        hook = r / ".git" / "hooks" / "pre-commit"
        hook.write_text(
            f'#!/bin/sh\n'
            f'files=$(git diff --cached --name-only --diff-filter=ACM | grep "\\.py$")\n'
            f'[ -z "$files" ] && exit 0\n'
            f'"{ruff_yol()}" check --no-cache --fix --select F,I $files\n',
            encoding="utf-8")
        hook.chmod(0o755)

        print("=== 1. Muammoli kod bilan commit urinishi ===")
        (r / "kod.py").write_text("import sys\nimport os\nx = 1\n", encoding="utf-8")
        git(r, "add", "kod.py")
        natija = git(r, "commit", "-m", "commit")
        print(f"  commit chiqish kodi: {natija.returncode} (hook tuzatdi, lekin fayl o'zgardi)")
        print(f"  fayl hook tomonidan tuzatildi: {'import' not in (r / 'kod.py').read_text(encoding='utf-8')}")

        print("\n=== 2. Tuzatilgan faylni qayta qo'shib commit ===")
        git(r, "add", "kod.py")
        natija = git(r, "commit", "-m", "toza commit")
        print(f"  commit chiqish kodi: {natija.returncode} (0 — muvaffaqiyat)")
        print(f"  commit yaratildi: {git(r, 'log', '--oneline').stdout.strip() != ''}")

        print("\n=== 3. ⚠️ --no-verify (hook'ni chetlab o'tish) ===")
        (r / "yomon.py").write_text("import os\ny = 1\n", encoding="utf-8")
        git(r, "add", "yomon.py")
        natija = git(r, "commit", "-m", "chetlab o'tildi", "--no-verify")
        print(f"  --no-verify bilan commit: kod {natija.returncode} (hook o'tkazib yuborildi)")
        print(f"  muammoli fayl commit qilindi: {natija.returncode == 0}")
        print("  ⚠️ --no-verify — faqat favqulodda holatda; muammo hal qilinmadi, faqat yashirildi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Muammoli kod bilan commit urinishi ===
  commit chiqish kodi: 0 (hook tuzatdi, lekin fayl o'zgardi)
  fayl hook tomonidan tuzatildi: True

=== 2. Tuzatilgan faylni qayta qo'shib commit ===
  commit chiqish kodi: 0 (0 — muvaffaqiyat)
  commit yaratildi: True

=== 3. ⚠️ --no-verify (hook'ni chetlab o'tish) ===
  --no-verify bilan commit: kod 0 (hook o'tkazib yuborildi)
  muammoli fayl commit qilindi: True
  ⚠️ --no-verify — faqat favqulodda holatda; muammo hal qilinmadi, faqat yashirildi

Nima ko'rsatdi: 2.4, 2.7-bo'limlar.

Misol 4 — Amaliy: to'liq sifat hook sozlash

Loyiha uchun to'liq sifat hook to'plamini sozlaymiz: .pre-commit-config.yaml yaratamiz (lint, format, xavfsizlik, umumiy tekshiruvlar), uni tahlil qilamiz va git hook simulyatsiyasi bilan ishlashini ko'rsatamiz. Bu — professional loyihaning sifat darvozasi.

python
"""to'liq pre-commit sozlash: lint, format, xavfsizlik, umumiy hook'lar; config tahlili; hook simulyatsiyasi (bir necha tekshiruv)."""

import shutil
import subprocess
import sys
import tempfile
from pathlib import Path

import yaml

CONFIG = """
repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.6.0
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-toml
      - id: detect-private-key
      - id: check-added-large-files
        args: [--maxkb=500]
"""


def ruff_yol() -> str:
    yol = shutil.which("ruff")
    if yol:
        return yol
    bin_papka = "Scripts" if sys.platform == "win32" else "bin"
    return str(Path(sys.executable).parent / bin_papka / ("ruff.exe" if sys.platform == "win32" else "ruff"))


def git(katalog: Path, *args: str):
    return subprocess.run(["git", "-C", str(katalog), *args], capture_output=True, text=True, encoding="utf-8")


def main() -> None:
    with tempfile.TemporaryDirectory() as katalog:
        r = Path(katalog)

        print("=== 1. Sifat hook to'plami ===")
        d = yaml.safe_load(CONFIG)
        toifalar = {"ruff": "lint", "ruff-format": "format", "trailing-whitespace": "umumiy",
                    "end-of-file-fixer": "umumiy", "check-toml": "umumiy",
                    "detect-private-key": "xavfsizlik", "check-added-large-files": "xavfsizlik"}
        from collections import Counter
        sanoq: Counter = Counter()
        for repo in d["repos"]:
            for hook in repo["hooks"]:
                sanoq[toifalar.get(hook["id"], "boshqa")] += 1
        for toifa, soni in sorted(sanoq.items()):
            print(f"  {toifa:12}: {soni} hook")

        print("\n=== 2. Xavfsizlik hook'lari ===")
        print("  detect-private-key — SSH/API kalitlar commit qilinmasin (⚠️ sirlar)")
        print("  check-added-large-files — 500KB dan katta fayllar bloklanadi")

        print("\n=== 3. Simulyatsiya: bir necha tekshiruv ===")
        git(r, "init")
        git(r, "config", "user.email", "t@wisar.uz")
        git(r, "config", "user.name", "T")
        hook = r / ".git" / "hooks" / "pre-commit"
        hook.write_text(
            f'#!/bin/sh\n'
            f'files=$(git diff --cached --name-only --diff-filter=ACM | grep "\\.py$")\n'
            f'[ -z "$files" ] && exit 0\n'
            f'# 1. maxfiy kalit tekshiruvi\n'
            f'if grep -rq "PRIVATE KEY" $files; then echo "XATO: maxfiy kalit topildi"; exit 1; fi\n'
            f'# 2. lint\n'
            f'"{ruff_yol()}" check --no-cache --select F,E $files\n',
            encoding="utf-8")
        hook.chmod(0o755)

        # muammoli: maxfiy kalit
        (r / "sozlama.py").write_text('KALIT = "-----BEGIN PRIVATE KEY-----"\n', encoding="utf-8")
        git(r, "add", "sozlama.py")
        natija = git(r, "commit", "-m", "kalit")
        print(f"  maxfiy kalitli commit: kod {natija.returncode} (bloklandi)")
        print(f"  'maxfiy kalit' xabari: {'maxfiy kalit' in natija.stdout + natija.stderr}")

        # toza kod
        (r / "sozlama.py").write_text("SOZLAMA = {'debug': False}\n", encoding="utf-8")
        git(r, "add", "sozlama.py")
        natija = git(r, "commit", "-m", "toza")
        print(f"  toza commit: kod {natija.returncode}, yaratildi: {git(r, 'log', '--oneline').stdout.strip() != ''}")
        print("  ⭐ pre-commit — lint, format va xavfsizlik darvozasi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Sifat hook to'plami ===
  format      : 1 hook
  lint        : 1 hook
  umumiy      : 3 hook
  xavfsizlik  : 2 hook

=== 2. Xavfsizlik hook'lari ===
  detect-private-key — SSH/API kalitlar commit qilinmasin (⚠️ sirlar)
  check-added-large-files — 500KB dan katta fayllar bloklanadi

=== 3. Simulyatsiya: bir necha tekshiruv ===
  maxfiy kalitli commit: kod 1 (bloklandi)
  'maxfiy kalit' xabari: True
  toza commit: kod 0, yaratildi: True
  ⭐ pre-commit — lint, format va xavfsizlik darvozasi

Nima ko'rsatdi: 2.5, 2.8-bo'limlar.


5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr To'g'risi
"Vositalarni qo'lda ishga tushirish yetarli" Unutiladi — pre-commit avtomatlashtiradi
"pre-commit CI ni almashtiradi" To'ldiradi — mahalliy + kafolat
"Hook faqat lint uchun" Format, xavfsizlik, test ham
"--no-verify normal" Faqat favqulodda holatda
"Hook config git'ga qo'shilmaydi" .pre-commit-config.yaml git'ga
"Hook o'rnatish avtomatik" pre-commit install bir marta
"Hook faylni tuzatmaydi" Ko'p hook (--fix) tuzatadi
"rev ixtiyoriy" Versiyani qulflaydi (takrorlanuvchanlik)

6. Keng tarqalgan xatolar va yechimlari

1. Vositalarni qo'lda ishga tushirishga tayanish

bash
# har safar eslab ruff/black                       # ❌ unutiladi
pre-commit install                                 # ✅ avtomatik

2. pre-commit install ni unutish

bash
# config bor, lekin o'rnatilmagan                   # ❌ hook ishlamaydi
pre-commit install                                 # ✅ klon qilgach bir marta

3. --no-verify ni muntazam ishlatish

bash
git commit --no-verify                             # ❌ maqsadni yo'qqa chiqaradi
# ✅ muammoni hal qiling, chetlab o'tmang

4. rev (versiya) siz

yaml
- repo: ...
  # rev yo'q                                        # ❌ versiya o'zgaradi
  rev: v0.6.0                                       # ✅ qulflang

5. CI da bir xil tekshiruv yo'q

yaml
# faqat pre-commit                                  # ❌ --no-verify chetlab o'tadi
# ✅ CI da ham ruff check, black --check (28-qism)

6. Xavfsizlik hook'larisiz

yaml
# faqat lint/format                                 # ⚠️ sirlar tushishi mumkin
- id: detect-private-key                            # ✅ xavfsizlik
- id: check-added-large-files

7. Hook'larni birinchi marta barcha faylda sinamaslik

bash
# faqat yangi commit'larda                          # eski kod tekshirilmaydi
pre-commit run --all-files                          # ✅ birinchi marta

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 18.4–18.5-darslar (o'tilgan): ruff, black — pre-commit hook'lari
  • 13-qism (o'tilgan): mypy — tur tekshiruvi hook'i
  • 17-qism (o'tilgan): testlar — pre-push hook'ida
  • 18.1-dars (o'tilgan): venv — pre-commit muhitda ishlaydi
  • 28-qism: CI/CD — pre-commit bilan bir xil tekshiruvlar

8. Eng yaxshi amaliyotlar

  1. pre-commit bilan sifat vositalarini avtomatlashtiring.

  2. .pre-commit-config.yaml ni git'ga qo'shing va rev bilan qulflang.

  3. Lint, format, xavfsizlik (detect-private-key) hook'larini qo'shing.

  4. Klon qilgach pre-commit install (yoki avtomatlashtiring).

  5. --no-verify ni faqat favqulodda holatda.

  6. Birinchi marta pre-commit run --all-files.

  7. CI da bir xil tekshiruvlarni takrorlang (kafolat).

  8. pre-commit autoupdate bilan hook'larni yangilab boring.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
1.  # pre-commit hook nol bo'lmagan kod qaytarsa, commit?
2.  # .pre-commit-config.yaml qaysi formatda?
3.  # rev nima uchun kerak?
4.  # detect-private-key nima qiladi?
5.  # git commit --no-verify nima qiladi?
6.  # pre-commit install nechta marta kerak?
7.  # ruff hook args=[--fix] nima qiladi?
8.  # hook fayl o'zgartirsa, keyin nima qilish kerak?
9.  # pre-commit CI ni almashtiradimi?
10. # end-of-file-fixer nima qiladi?
11. # check-added-large-files nimani bloklaydi?
12. # pre-commit run --all-files nima qiladi?
Javoblar
  1. Bekor qilinadi (bloklanadi)
  2. YAML
  3. Hook versiyasini qulflaydi (takrorlanuvchanlik)
  4. Maxfiy kalitlarni topib commit'ni bloklaydi
  5. Hook'larni chetlab o'tadi
  6. Bir marta (klon qilgach)
  7. Muammolarni avtomatik tuzatadi
  8. Tuzatilgan faylni qayta git add
  9. Yo'q — to'ldiradi
  10. Fayl oxirida bitta yangi qator qo'yadi
  11. Belgilangan hajmdan katta fayllarni
  12. Barcha faylda hook'larni ishga tushiradi

Vazifa 2: Xatolarni tuzating

yaml
1.  repos:
      - repo: https://github.com/astral-sh/ruff-pre-commit
        hooks:                              # rev yo'q
          - id: ruff

2.  # ish oqimi:
    # config yaratildi, lekin pre-commit install qilinmadi

3.  # commit:
    git commit --no-verify -m "tez"         # muntazam

4.  repos:
      - repo: ...
        rev: v0.6.0
        hooks:
          - id: ruff
    # detect-private-key, check-large-files yo'q

5.  # CI:
    # faqat pre-commit, CI da tekshiruv yo'q
Javoblar
yaml
1.  repos:
      - repo: https://github.com/astral-sh/ruff-pre-commit
        rev: v0.6.0                         # versiya qulflandi
        hooks:
          - id: ruff

2.  # klon qilgach:
    pre-commit install                      # hook o'rnatildi

3.  git commit -m "tez"                     # hook o'tsin (favqulodda emas)

4.  # xavfsizlik hook'lari qo'shildi:
    - repo: https://github.com/pre-commit/pre-commit-hooks
      rev: v4.6.0
      hooks:
        - id: detect-private-key
        - id: check-added-large-files

5.  # CI da ham (28-qism):
    # ruff check . && ruff format --check .

Vazifa 3: To'liq config yaratish

Loyiha uchun .pre-commit-config.yaml:

  1. Lint (ruff), format (ruff-format)
  2. Umumiy (trailing-whitespace, end-of-file-fixer, check-yaml)
  3. Xavfsizlik (detect-private-key, check-added-large-files)
  4. rev bilan versiyalarni qulflang; yaml bilan tekshiring

Vazifa 4: Maxsus hook

O'z hook'ingizni yozing (repo: local):

  1. Fayllarda "TODO" yoki "FIXME" ni topib ogohlantirsin
  2. print() chaqiruvlarini topsin (ishlab chiqarish kodida)
  3. Commit xabari formatini tekshirsin (commit-msg hook)
  4. .pre-commit-config.yaml ga qo'shing

Vazifa 5: Hook simulyatsiyasi

Vaqtinchalik git repo bilan:

  1. pre-commit hook o'rnating (ruff tekshiruvi)
  2. Muammoli commit bloklashini ko'rsating
  3. Toza commit o'tishini ko'rsating
  4. --no-verify chetlab o'tishini ko'rsating

Vazifa 6: Xavfsizlik darvozasi

  1. detect-private-key hook mantiqini yozing
  2. Turli kalit formatlarini (SSH, PEM) toping
  3. .env fayllarini bloklang
  4. Katta fayl tekshiruvini qo'shing

Vazifa 7: O'ylash

pre-commit "chapga siljish" (shift left) tamoyilining namunasi — muammolarni jarayonning imkon qadar erta (commit paytida) ushlash. An'anaviy yondashuvda muammolar kech (test, ishlab chiqarish) topilardi. Nima uchun muammoni erta ushlash muhim, va bu "chapga siljish" g'oyasi dasturlash va sifat haqida nimani o'rgatadi?

Javob

Qisqa javob: Muammoni erta ushlash muhim, chunki xatoni tuzatish narxi vaqt bilan eksponensial o'sadi: commit paytida topilgan lint xatosi — bir soniya, kod ko'rigida — daqiqalar, ishlab chiqarishda — soatlar va obro' zarari. "Chapga siljish" (shift left) — sifat tekshiruvlarini jarayonning boshiga (chapga) surish, muammolar arzon bo'lganda ushlash. pre-commit buni git ish oqimiga singdiradi: muammo repozitoriyga umuman tushmaydi.

1. Nega erta ushlash arzon

Bosqich Tuzatish narxi
Yozayotganda (muharrir) Soniyalar
Commit (pre-commit) Soniyalar
Kod ko'rigi (PR) Daqiqalar (odam vaqti)
CI Daqiqalar (qayta ishlash)
Ishlab chiqarish Soatlar + obro'

2. "Chapga siljish" nima

Dasturlash jarayoni chapdan o'ngga: rejalashtirish → kod → test → deploy. "Chapga siljish" — sifat tekshiruvlarini chapga (boshiga) surish:

An'anaviy (o'ngda) Chapga siljish
Test bosqichida sifat Yozayotganda
Ishlab chiqarishda topish Commit'da
QA jamoasi Har dasturchi

3. pre-commit qanday qo'llaydi

Qatlam Qachon
Muharrir (real vaqt) Yozayotganda
pre-commit Commit'da
CI Push/PR'da
Ishlab chiqarish Deploy'da

Har qatlam oldingisi o'tkazib yuborganini ushlaydi.

4. Umumiy tamoyil

Soha Chapga siljish
Sifat pre-commit, lint
Xavfsizlik Erta skanerlash (SAST)
Test TDD (17.8)
Tur Type hints (13-qism)

5. Muhandislik saboqlari

  1. Xato narxi vaqt bilan o'sadi — erta ushlang
  2. Avtomatlashtirish — inson unutadi
  3. Ko'p qatlamli himoya (muharrir, commit, CI)
  4. Sifat — jarayon, oxirgi bosqich emas

6. Xulosa

  1. Erta ushlash arzon (narx eksponensial o'sadi)
  2. "Chapga siljish" — tekshiruvni boshiga surish
  3. pre-commit — sifatni git oqimiga singdiradi
  4. Ko'p qatlamli, avtomatlashtirilgan himoya

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.


Xulosa

Bu darsda pre-commit bilan sifat tekshiruvlarini avtomatlashtirishni o'rgandik.

Eng muhim uch fikr:

  1. pre-commit — commit'dan oldin avtomatik tekshiruv. Git pre-commit hook commit yaratilishidan oldin ishlaydi va nol bo'lmagan chiqish kodi qaytarsa, commit bekor qilinadi. pre-commit vositasi xom git hook'larni soddalashtiradi: hook'larni .pre-commit-config.yaml da e'lon qilasiz (git'ga qo'shiladi, rev bilan versiya qulflanadi), pre-commit install bir marta o'rnatadi, va butun jamoa bir xil hook'larni oladi.

  2. Muammoli kod repozitoriyga tusha olmaydi. Vositalarni qo'lda ishga tushirish unutiladi — pre-commit ularni avtomatlashtiradi. Keng tarqalgan hook'lar: ruff (lint), ruff-format/black (format), trailing-whitespace/end-of-file-fixer (umumiy), va — muhimi — detect-private-key, check-added-large-files (xavfsizlik: sirlar va katta fayllar tushishining oldini oladi). Ko'p hook muammoni o'zi tuzatadi; keyin tuzatilgan faylni qayta git add qilasiz.

  3. pre-commit + CI, --no-verify ehtiyot bilan. pre-commit (mahalliy) muammolarni erta ushlaydi — bu "chapga siljish" tamoyili: xato narxi vaqt bilan eksponensial o'sadi, shuning uchun uni commit paytida (arzon) ushlash muhim. CI (28-qism) esa kafolat beradi (kimdir --no-verify bilan chetlab o'tsa ham) — shuning uchun CI da bir xil tekshiruvlar takrorlanadi. --no-verify ni faqat haqiqiy favqulodda holatda ishlating — muammoni chetlab o'tish emas, hal qilish kerak.

Keyingi darsda kod tezligini o'lchashni — profiling ni o'rganamiz: timeit va cProfile bilan kodning qaysi qismi sekin ishlashini aniqlash va optimizatsiyani qayerga yo'naltirishni bilish.

Sifat va vositalar · 6-dars yakunlandi

18.6-dars: pre-commit

19 daqvaqt
0belgi
Keyingi dars: 18.7-dars: Profiling — cProfile va timeit
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0