18.6-dars: pre-commit
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-commitnima -
.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 mexanizmigitvasubprocessbilan 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:
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
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
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:
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
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!)# .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-formatQoidalar
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) birga4. Batafsil misollar
Misollarda git hook mexanizmi vaqtinchalik git repozitoriyda ko'rsatiladi;
pre-commitconfig tuzilishiyamlbilan tahlil qilinadi.
Misol 1 — .pre-commit-config.yaml tuzilishi
"""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:
=== 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
"""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:
=== 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 qilindiNima ko'rsatdi: 2.1, 2.4-bo'limlar.
Misol 3 — Hook o'zi tuzatadi va --no-verify
"""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:
=== 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 yashirildiNima 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.
"""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:
=== 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 darvozasiNima 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
# har safar eslab ruff/black # ❌ unutiladi
pre-commit install # ✅ avtomatik2. pre-commit install ni unutish
# config bor, lekin o'rnatilmagan # ❌ hook ishlamaydi
pre-commit install # ✅ klon qilgach bir marta3. --no-verify ni muntazam ishlatish
git commit --no-verify # ❌ maqsadni yo'qqa chiqaradi
# ✅ muammoni hal qiling, chetlab o'tmang4. rev (versiya) siz
- repo: ...
# rev yo'q # ❌ versiya o'zgaradi
rev: v0.6.0 # ✅ qulflang5. CI da bir xil tekshiruv yo'q
# faqat pre-commit # ❌ --no-verify chetlab o'tadi
# ✅ CI da ham ruff check, black --check (28-qism)6. Xavfsizlik hook'larisiz
# faqat lint/format # ⚠️ sirlar tushishi mumkin
- id: detect-private-key # ✅ xavfsizlik
- id: check-added-large-files7. Hook'larni birinchi marta barcha faylda sinamaslik
# faqat yangi commit'larda # eski kod tekshirilmaydi
pre-commit run --all-files # ✅ birinchi marta7. 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
pre-commitbilan sifat vositalarini avtomatlashtiring..pre-commit-config.yamlni git'ga qo'shing varevbilan qulflang.Lint, format, xavfsizlik (
detect-private-key) hook'larini qo'shing.Klon qilgach
pre-commit install(yoki avtomatlashtiring).--no-verifyni faqat favqulodda holatda.Birinchi marta
pre-commit run --all-files.CI da bir xil tekshiruvlarni takrorlang (kafolat).
pre-commit autoupdatebilan hook'larni yangilab boring.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
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
- Bekor qilinadi (bloklanadi)
- YAML
- Hook versiyasini qulflaydi (takrorlanuvchanlik)
- Maxfiy kalitlarni topib commit'ni bloklaydi
- Hook'larni chetlab o'tadi
- Bir marta (klon qilgach)
- Muammolarni avtomatik tuzatadi
- Tuzatilgan faylni qayta
git add - Yo'q — to'ldiradi
- Fayl oxirida bitta yangi qator qo'yadi
- Belgilangan hajmdan katta fayllarni
- Barcha faylda hook'larni ishga tushiradi
Vazifa 2: Xatolarni tuzating
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'qJavoblar
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:
- Lint (ruff), format (ruff-format)
- Umumiy (trailing-whitespace, end-of-file-fixer, check-yaml)
- Xavfsizlik (detect-private-key, check-added-large-files)
revbilan versiyalarni qulflang;yamlbilan tekshiring
Vazifa 4: Maxsus hook
O'z hook'ingizni yozing (repo: local):
- Fayllarda "TODO" yoki "FIXME" ni topib ogohlantirsin
print()chaqiruvlarini topsin (ishlab chiqarish kodida)- Commit xabari formatini tekshirsin (
commit-msghook) .pre-commit-config.yamlga qo'shing
Vazifa 5: Hook simulyatsiyasi
Vaqtinchalik git repo bilan:
pre-commithook o'rnating (ruff tekshiruvi)- Muammoli commit bloklashini ko'rsating
- Toza commit o'tishini ko'rsating
--no-verifychetlab o'tishini ko'rsating
Vazifa 6: Xavfsizlik darvozasi
detect-private-keyhook mantiqini yozing- Turli kalit formatlarini (SSH, PEM) toping
.envfayllarini bloklang- 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
- Xato narxi vaqt bilan o'sadi — erta ushlang
- Avtomatlashtirish — inson unutadi
- Ko'p qatlamli himoya (muharrir, commit, CI)
- Sifat — jarayon, oxirgi bosqich emas
6. Xulosa
- Erta ushlash arzon (narx eksponensial o'sadi)
- "Chapga siljish" — tekshiruvni boshiga surish
pre-commit— sifatni git oqimiga singdiradi- 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:
pre-commit— commit'dan oldin avtomatik tekshiruv. Gitpre-commithook commit yaratilishidan oldin ishlaydi va nol bo'lmagan chiqish kodi qaytarsa, commit bekor qilinadi.pre-commitvositasi xom git hook'larni soddalashtiradi: hook'larni.pre-commit-config.yamlda e'lon qilasiz (git'ga qo'shiladi,revbilan versiya qulflanadi),pre-commit installbir marta o'rnatadi, va butun jamoa bir xil hook'larni oladi.Muammoli kod repozitoriyga tusha olmaydi. Vositalarni qo'lda ishga tushirish unutiladi —
pre-commitularni 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 qaytagit addqilasiz.pre-commit+ CI,--no-verifyehtiyot 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-verifybilan chetlab o'tsa ham) — shuning uchun CI da bir xil tekshiruvlar takrorlanadi.--no-verifyni 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.
Izohlar · 0
Izoh yozish uchun kiring.