31.1-dars: Loyiha 1 — CLI vosita (PyPI'da)

31-QISM — KARYERA VA KATTA LOYIHALAR · 1-dars

1. Kirish va motivatsiya

Kursning yakuniy qismiga yetdik — endi bilimlarni real, to'liq loyihalarga tatbiq etamiz. Birinchi loyiha: CLI vosita (Command-Line Interface — buyruq qatori dasturi), uni professional darajada paketlab, PyPI'ga (Python paket ombori) chiqarish. Nima uchun aynan CLI? Chunki u kichik, lekin to'liq loyiha: argument tahlili, biznes logika, testlar, hujjat, paketlash, tarqatish — hamma bosqichlar bor. Va u portfolioingizda ajoyib ko'rinadi: "men yozgan vositani dunyoda har kim pip install qila oladi". Bu dars CLI vositani noldan qurishni, pyproject.toml bilan paketlashni, entry_points bilan buyruq yaratishni va PyPI'ga chiqarishni ko'rsatadi — real dasturchi ko'nikmasi.

CLI vosita loyihasi — buyruq qatori dasturini professional paketlab, PyPI'ga chiqarish: argument tahlili (argparse/click — buyruq argumentlari), loyiha tuzilishi (src/ paket, testlar, hujjat), paketlash (pyproject.toml — metama'lumot, bog'liqliklar), entry_points (buyruq nomi — pip installdan keyin terminalda ishlaydi), PyPI (build + twine — tarqatish). Foydalanish: real vosita yaratish, portfolio, ochiq kod. Bu 24-qism (paketlash), 22-qism (CLI kutubxonalar) ni birlashtiradi. Bu 24-qism (PyPI), 31.8 (portfolio) bilan bog'liq. CLI loyiha — to'liq paket. entry_points. PyPI'ga.

Real vaziyat. Dasturchi takroriy vazifani (fayllarni qayta nomlash — ma'lum qoida bo'yicha) avtomatlashtirdi. Bir marta ishlaydigan skript emas, qayta ishlatiladigan vosita qildi: argparse (argumentlar — papka, qoida), src/renamer/ (paket), testlar (pytest), pyproject.toml (paketlash), entry_points (renamer buyrug'I). PyPI'ga chiqardi (build + twine). Endi har kim pip install renamer → terminalda renamer papka --qoida .... Bu portfoliogA qo'shildi (GitHub + PyPI havola). CLI loyiha — skriptdan professional vositaga.

Bu darsda CLI vosita loyihasini PyPI'ga chiqarishni o'rganamiz.

Bu darsda:

• CLI loyiha tuzilishi
• Argument tahlili (argparse/click)
• pyproject.toml (paketlash)
• entry_points (buyruq)
• PyPI'ga chiqarish (build + twine)
• Loyiha amaliyoti
• Loyihani mustahkamlash
• Amaliy: CLI loyiha modeli

ℹ To'liq loyiha ko'p fayl/vosita talab qiladi; misollar loyiha tuzilishi mantiqini (deterministik) modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. CLI loyiha tuzilishi

Professional paket tuzilishi:

renamer/                    # loyiha ildizi
├── src/
│   └── renamer/            # paket
│       ├── __init__.py
│       ├── cli.py          # argument tahlili (kirish nuqtasi)
│       └── core.py         # biznes logika
├── tests/
│   └── test_core.py        # testlar (pytest)
├── pyproject.toml          # paketlash (metama'lumot)
├── README.md               # hujjat
└── LICENSE                 # litsenziya

CLI loyiha tuzilishi — professional paket standart tartibi: src/paket/ (kod — cli.py argument/kirish, core.py biznes logika — ajratish 27-qism), tests/ (testlar — pytest 20-qism), pyproject.toml (paketlash — metama'lumot, bog'liqliklar), README.md (hujjat — foydalanish), LICENSE (litsenziya — ochiq kod huquqi). Sabab: real loyiha tartibli bo'lishi kerak (skript emas — 27-qism arxitektura); src/ tartibi (kod alohida — import muammolari oldini), testlar (ishonch), hujjat (foydalanuvchi). Bu 24-qism (paket tuzilishi) standart. CLI loyiha — src, tests, pyproject, README. Tartibli. Professional.

2.2. Argument tahlili (argparse/click)

Buyruq argumentlarini o'qish:

# cli.py — argparse (standart kutubxona)
import argparse


def main() -> None:
    parser = argparse.ArgumentParser(description="Fayllarni qayta nomlash")
    parser.add_argument("papka", help="Papka yo'li")
    parser.add_argument("--qoida", required=True, help="Nomlash qoidasi")
    parser.add_argument("--test", action="store_true", help="Sinov rejimi")
    args = parser.parse_args()

    # args.papka, args.qoida, args.test — foydalanish
    print(f"Papka: {args.papka}, qoida: {args.qoida}")

Argument tahlili (argparse/click) — CLI vositaning kirish qismi: buyruq qatori argumentlarini o'qish (renamer papka --qoida X). argparse (standart kutubxona — add_argument, pozitsion papka, ixtiyoriy --qoida, bayroq --test), click (uchinchi tomon — dekoratorlar, qulayroq). Sabab: CLI foydalanuvchidan kirish oladi (argumentlar); argparse/click ularni tahlil qiladi (parse — o'qish, tekshirish, yordam). argparse avtomatik --help beradi (hujjat). Foydalanish: pozitsion (majburiy — papka), --flag (ixtiyoriy), action="store_true" (bayroq). Argument tahlili — CLI kirish (argparse/click). Kirish nuqtasi. --help avtomatik.

2.3. pyproject.toml (paketlash)

Loyiha metama'lumoti:

# pyproject.toml — paket ta'rifi
[build-system]
requires = ["setuptools>=61"]
build-backend = "setuptools.build_meta"

[project]
name = "renamer"
version = "1.0.0"
description = "Fayllarni qoida bo'yicha qayta nomlash"
readme = "README.md"
requires-python = ">=3.9"
dependencies = ["click>=8.0"]

[project.scripts]
renamer = "renamer.cli:main"      # entry point (buyruq)

pyproject.toml — zamonaviy Python paket konfiguratsiya fayli (24-qism): [build-system] (yig'ish vositasi — setuptools), [project] (metama'lumot — name, version, description, dependencies bog'liqliklar), [project.scripts] (entry_points — buyruq 2.4). Sabab: paket ta'riflanishi kerak (nom, versiya, bog'liqliklar — pip biladi); pyproject.toml bu standart (deklarativ — setup.py kod o'rniga, 30.11 maturin kabi). version (semantik — 24-qism), dependencies (kerakli paketlar — avtomatik o'rnatiladi). Bu 24-qism (paketlash) markazi. pyproject.toml — paket ta'rifi (deklarativ). name, version, dependencies. Standart.

2.4. entry_points (buyruq)

pip install'dan keyin terminal buyrug'i:

[project.scripts]
renamer = "renamer.cli:main"
#  │         │          │
#  │         │          └─ funksiya (main)
#  │         └─ modul (renamer.cli)
#  └─ terminal buyrug'i (renamer)

# pip install renamer'dan keyin:
renamer /papka --qoida X    # terminalda buyruq (main() chaqiriladi)

entry_points ([project.scripts]) — CLI vositaning sehri: pip installdan keyin terminal buyrug'I yaratadi (renamer — istalgan joyda). Format: buyruq = "modul:funksiya" (renamer = "renamer.cli:main" — renamer buyrug'I renamer.cli modulining main funksiyasini chaqiradi). Sabab: foydalanuvchi python -m renamer.cli emas, oddiy renamer yozishi kerak (professional — tizim buyrug'I kabi); entry_points pipga buyruq yaratishni aytadi (avtomatik — PATHga qo'shadi). Bu CLI vositani haqiqiy vosita qiladi (git, docker kabi terminal buyrug'I). entry_points — terminal buyrug'I (modul:funksiya). pip yaratadi. Professional CLI.

2.5. PyPI'ga chiqarish (build + twine)

Dunyoga tarqatish:

# 1. Yig'ish (paket yaratish)
pip install build
python -m build              # dist/*.whl + dist/*.tar.gz

# 2. Yuklash (PyPI'ga)
pip install twine
twine upload dist/*          # PyPI'ga (autentifikatsiya)

# 3. Endi har kim:
pip install renamer          # dunyodan o'rnatadi

PyPI'ga chiqarish (build + twine) — CLI vositani dunyoga tarqatish: build (python -m build — paket yaratadi, dist/ da .whl + .tar.gz — 30.11 kabi), twine (twine upload dist/* — PyPI'ga yuklaydi, autentifikatsiya bilan). Sabab: vosita foydali bo'lsa — boshqalar ishlatishi kerak (tarqatish); PyPI standart (24-qism — pip install shundan). Oqim: build (yig') → twine upload (yukla) → har kim pip install renamer. Cheklov: PyPI hisobi kerak (ro'yxatdan o'tish), nom noyob bo'lishi (band emas), versiya oshirilishi (har chiqarish yangi). Bu 24-qism (tarqatish) yakuni. PyPI — build + twine. dist → upload. pip install (dunyodan).

2.6. Loyiha amaliyoti

CLI loyiha amaliyotlari: tuzilish (src/, tests, pyproject — 2.1); argument (argparse/click — kirish, --help); ajratish (cli.py kirish, core.py logika — 27-qism, test oson); testlar (pytest — core logika, 20-qism); pyproject.toml (metama'lumot, dependencies, entry_points); README (foydalanish, misollar — hujjat); versiya (semantik — 1.0.0, har chiqarish oshir); PyPI (build + twine). Tuzoqlar: cli va core aralashtirish (test qiyin — ajrat), test yo'q (ishonchsiz), README yo'q (foydalanuvchi bilmaydi), nom band (PyPI noyob), versiya oshirmaslik. Amaliyot — tuzilish, argument, ajratish, test, PyPI. CLI — to'liq professional loyiha.

2.7. Loyihani mustahkamlash (portfolio)

CLI loyihani portfolio uchun mustahkamlash: GitHub (kod — README, litsenziya, aniq tuzilish — 31.8); PyPI havola ("pip install qiling" — real, ishlatiladi); CI (GitHub Actions — test avtomatik, 28.7); badge (README'da — test o'tdi, PyPI versiya); hujjat (foydalanish, misollar — o'qiladi); testlar (qamrov — ishonch); CHANGELOG (o'zgarishlar tarixi). Sabab: portfolioda loyiha ishonchli ko'rinishi kerak (31.8 — ish beruvchi ko'radi); to'liq loyiha (test, hujjat, CI, PyPI) professionallik ko'rsatadi (skript emas). Bu 31.8 (portfolio), 28.7 (CI) bilan bog'liq. Mustahkamlash — GitHub, PyPI, CI, hujjat. Portfolio uchun. Professionallik.

2.8. CLI loyiha — bilimlarni birlashtirish

CLI loyiha asosiy g'oyasi — bilimlarni birlashtirish: bir kichik, lekin to'liq loyihada kurs bilimlarini qo'llash — argument (22-qism CLI), biznes logika (funksiyalar, klasslar — 5, 16-qism), testlar (20-qism), paketlash (24-qism), ajratish (27-qism arxitektura), CI (28-qism), tarqatish (PyPI). Bu real dasturchi ishi (skript emas — professional vosita); portfolioda kuchli (31.8 — "dunyo pip install qiladi"). CLI kichik (boshlash oson), lekin hamma bosqich bor (argument → logika → test → paket → PyPI). Bu 31-qism (karyera — real loyihalar) ning birinchi amaliyoti. Keyingi loyihalar (REST API 31.2, ETL 31.3, mikroservis 31.4) kattaroq. CLI loyiha — to'liq, kichik. Bilimlar birlashadi. Professional boshlanish.

3. Tez ma'lumotnoma

CLI LOYIHA TUZILISHI:
   src/renamer/  (cli.py + core.py) · tests/ · pyproject.toml · README.md

# ARGUMENT TAHLILI (argparse)
import argparse
parser = argparse.ArgumentParser(description="...")
parser.add_argument("papka")              # pozitsion (majburiy)
parser.add_argument("--qoida", required=True)   # ixtiyoriy
parser.add_argument("--test", action="store_true")   # bayroq
args = parser.parse_args()

# PYPROJECT.TOML (paketlash)
[project]
name = "renamer"
version = "1.0.0"
dependencies = ["click>=8.0"]

[project.scripts]
renamer = "renamer.cli:main"    # entry point (terminal buyrug'i)

# PYPI'GA CHIQARISH:
python -m build          # dist/*.whl + *.tar.gz
twine upload dist/*      # PyPI'ga yuklash
# → pip install renamer (har kim, dunyodan)

# QOIDA: src/ tuzilish · cli/core ajrat · test · pyproject · PyPI

CLI loyiha xulosasi

CLI loyiha — buyruq vositasi, professional paket (PyPI)
Argument tahlili — argparse/click (kirish, --help)
pyproject.toml — paket ta'rifi (name, version, dependencies)
entry_points — terminal buyrug'i (modul:funksiya)
PyPI — build + twine → pip install (dunyo) · portfolio

4. Batafsil misollar

To'liq loyiha ko'p fayl/vosita talab qiladi; misollar loyiha tuzilishi mantiqini (deterministik) modellashtiradi.

Misol 1 — Loyiha tuzilishi (fayllar)

"""Loyiha tuzilishi: professional CLI paket (model)."""


LOYIHA = {
    "src/renamer/cli.py": "argument tahlili (kirish nuqtasi)",
    "src/renamer/core.py": "biznes logika",
    "tests/test_core.py": "testlar (pytest)",
    "pyproject.toml": "paketlash (metama'lumot)",
    "README.md": "hujjat",
    "LICENSE": "litsenziya",
}


def main() -> None:
    print("=== 1. Loyiha fayllari ===")
    for fayl, maqsad in LOYIHA.items():
        print(f"  {fayl:26} — {maqsad}")

    print("\n=== 2. Ajratish (27-qism) ===")
    print("  cli.py (kirish) vs core.py (logika)")

    print("\n=== 3. Test (20-qism) ===")
    print("  core.py logikasi test qilinadi (cli emas)")

    print("\n=== 4. Professional ===")
    print("  src/, tests/, pyproject — tartibli (skript emas)")
    print("  ⭐ Loyiha tuzilishi — src, tests, paket")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Loyiha fayllari ===
  src/renamer/cli.py         — argument tahlili (kirish nuqtasi)
  src/renamer/core.py        — biznes logika
  tests/test_core.py         — testlar (pytest)
  pyproject.toml             — paketlash (metama'lumot)
  README.md                  — hujjat
  LICENSE                    — litsenziya

=== 2. Ajratish (27-qism) ===
  cli.py (kirish) vs core.py (logika)

=== 3. Test (20-qism) ===
  core.py logikasi test qilinadi (cli emas)

=== 4. Professional ===
  src/, tests/, pyproject — tartibli (skript emas)
  ⭐ Loyiha tuzilishi — src, tests, paket

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Argument tahlili (argparse)

"""Argument tahlili: argparse bilan CLI kirish (model)."""

import argparse


def parser_yarat() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(description="Fayllarni qayta nomlash")
    p.add_argument("papka", help="Papka yo'li")
    p.add_argument("--qoida", required=True, help="Nomlash qoidasi")
    p.add_argument("--test", action="store_true", help="Sinov rejimi")
    return p


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

    print("=== 1. Argumentlar ===")
    print("  papka (pozitsion, majburiy)")
    print("  --qoida (ixtiyoriy, majburiy qiymat)")
    print("  --test (bayroq, store_true)")

    print("\n=== 2. Tahlil (namuna) ===")
    args = parser.parse_args(["/hujjatlar", "--qoida", "sana", "--test"])
    print(f"  papka: {args.papka}")
    print(f"  qoida: {args.qoida}")
    print(f"  test: {args.test}")

    print("\n=== 3. Avtomatik --help ===")
    print("  argparse yordam matnini o'zi yaratadi")

    print("\n=== 4. Kirish nuqtasi ===")
    print("  CLI foydalanuvchidan argument oladi")
    print("  ⭐ Argument tahlili — argparse (kirish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Argumentlar ===
  papka (pozitsion, majburiy)
  --qoida (ixtiyoriy, majburiy qiymat)
  --test (bayroq, store_true)

=== 2. Tahlil (namuna) ===
  papka: /hujjatlar
  qoida: sana
  test: True

=== 3. Avtomatik --help ===
  argparse yordam matnini o'zi yaratadi

=== 4. Kirish nuqtasi ===
  CLI foydalanuvchidan argument oladi
  ⭐ Argument tahlili — argparse (kirish)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — entry_points (buyruq)

"""entry_points: terminal buyrug'i ta'rifi (model)."""


def entry_point_parse(satr: str) -> dict:
    # "renamer = renamer.cli:main"
    buyruq, target = satr.split(" = ")
    modul, funksiya = target.split(":")
    return {"buyruq": buyruq, "modul": modul, "funksiya": funksiya}


def main() -> None:
    ep = entry_point_parse("renamer = renamer.cli:main")

    print("=== 1. entry_point ===")
    print(f"  buyruq: {ep['buyruq']} (terminalda)")
    print(f"  modul: {ep['modul']}")
    print(f"  funksiya: {ep['funksiya']}")

    print("\n=== 2. pip install'dan keyin ===")
    print(f"  {ep['buyruq']} /papka --qoida X")
    print(f"  → {ep['modul']}:{ep['funksiya']} chaqiriladi")

    print("\n=== 3. Professional ===")
    print("  git, docker kabi terminal buyrug'i")

    print("\n=== 4. pip yaratadi ===")
    print("  entry_points → PATH'ga buyruq (avtomatik)")
    print("  ⭐ entry_points — terminal buyrug'i (modul:funksiya)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. entry_point ===
  buyruq: renamer (terminalda)
  modul: renamer.cli
  funksiya: main

=== 2. pip install'dan keyin ===
  renamer /papka --qoida X
  → renamer.cli:main chaqiriladi

=== 3. Professional ===
  git, docker kabi terminal buyrug'i

=== 4. pip yaratadi ===
  entry_points → PATH'ga buyruq (avtomatik)
  ⭐ entry_points — terminal buyrug'i (modul:funksiya)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — PyPI oqimi (build + twine)

"""PyPI oqimi: build → twine → pip install (model)."""


def pypi_oqim(paket: str, versiya: str) -> list:
    return [
        f"python -m build → dist/{paket}-{versiya}.whl",
        f"twine upload dist/* → PyPI ({paket} {versiya})",
        f"pip install {paket} (har kim, dunyodan)",
        f"{paket} (terminal buyrug'i ishlaydi)",
    ]


def main() -> None:
    print("=== 1. PyPI oqimi ===")
    for i, qadam in enumerate(pypi_oqim("renamer", "1.0.0"), 1):
        print(f"  {i}. {qadam}")

    print("\n=== 2. build ===")
    print("  paket yaratadi (.whl + .tar.gz)")

    print("\n=== 3. twine ===")
    print("  PyPI'ga yuklaydi (autentifikatsiya)")

    print("\n=== 4. Natija ===")
    print("  dunyoda har kim pip install (portfolio)")
    print("  ⭐ PyPI — build + twine (tarqatish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. PyPI oqimi ===
  1. python -m build → dist/renamer-1.0.0.whl
  2. twine upload dist/* → PyPI (renamer 1.0.0)
  3. pip install renamer (har kim, dunyodan)
  4. renamer (terminal buyrug'i ishlaydi)

=== 2. build ===
  paket yaratadi (.whl + .tar.gz)

=== 3. twine ===
  PyPI'ga yuklaydi (autentifikatsiya)

=== 4. Natija ===
  dunyoda har kim pip install (portfolio)
  ⭐ PyPI — build + twine (tarqatish)

Nima ko'rsatdi: 2.5-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. cli va core aralashtirish

# cli.py'da biznes logika (test qiyin)                        # ⚠️
# core.py (logika) + cli.py (argument) ajrat                   # ✅

2. entry_points yo'q

# python -m renamer.cli (noqulay)                             # ⚠️
# [project.scripts] renamer = "renamer.cli:main"               # ✅

3. Test yo'q

# CLI qo'lda sinash (ishonchsiz)                              # ⚠️
# pytest (core logika — avtomatik test)                        # ✅

4. Band nom (PyPI)

# name = "requests" (band — xato)                             # ⚠️
# noyob nom (PyPI'da tekshir)                                  # ✅

5. Versiya oshirmaslik

# 1.0.0 qayta upload (PyPI rad etadi)                         # ⚠️
# har chiqarish versiya oshir (1.0.1, 1.1.0)                   # ✅

6. dependencies unutish

# click ishlatiladi, dependencies'da yo'q (o'rnatilmaydi)     # ⚠️
dependencies = ["click>=8.0"]                                  # ✅

7. README/LICENSE yo'q

# hujjatsiz, litsenziyasiz (foydalanuvchi ishonmaydi)         # ⚠️
# README (foydalanish) + LICENSE (huquq)                       # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 31.8-dars: Portfolio va GitHub — loyihani ko'rsatish
• 24-qism (o'tilgan): Paketlash va PyPI
• 22-qism (o'tilgan): CLI kutubxonalar (argparse/click)
• 20-qism (o'tilgan): Testlar (pytest)
• 28.7-dars (o'tilgan): CI/CD — avtomatik test

8. Eng yaxshi amaliyotlar

1. src/ tuzilish (cli.py + core.py ajrat).

2. argparse/click (argument, --help).

3. core logika test (pytest — ishonch).

4. pyproject.toml (metama'lumot, dependencies).

5. entry_points (terminal buyrug'i).

6. README + LICENSE (hujjat, huquq).

7. Semantik versiya (har chiqarish oshir).

8. PyPI + GitHub (portfolio — real vosita).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # CLI loyiha tuzilishi?
2.  # cli.py va core.py?
3.  # nega ajratish?
4.  # argparse nima?
5.  # pozitsion vs --flag?
6.  # pyproject.toml nima?
7.  # dependencies nima?
8.  # entry_points nima?
9.  # entry_point formati?
10. # build nima?
11. # twine nima?
12. # nega versiya oshir?

Vazifa 2: Xatolarni tuzating

1.  # cli.py'da biznes logika

2.  # python -m renamer.cli (entry_point yo'q)

3.  # CLI qo'lda sinash

4.  name = "requests"   # band

5.  # 1.0.0 qayta upload

1.  core.py (logika) + cli.py (argument)

2.  [project.scripts] renamer = "renamer.cli:main"

3.  pytest (core test)

4.  noyob nom (PyPI'da tekshir)

5.  versiya oshir (1.0.1)

Vazifa 3: Tuzilish

Modellang:

1. src/paket
2. cli/core
3. tests
4. pyproject

Vazifa 4: Argument

Modellang:

1. Pozitsion
2. --flag
3. Bayroq
4. --help

Vazifa 5: entry_points

Modellang:

1. Buyruq
2. Modul
3. Funksiya
4. Terminal

Vazifa 6: PyPI

Modellang:

1. build
2. twine
3. pip install
4. Portfolio

Vazifa 7: O'ylash

CLI loyiha "kichik, lekin to'liq" — argument, logika, test, paket, tarqatish — hamma bosqich bor. Nima uchun "kichik lekin to'liq" loyiha o'rganish va portfolio uchun "katta lekin chala"dan yaxshiroq, va nega "boshidan oxirigacha yakunlangan ish" (hattoki kichik) dasturchi mahoratini "yarim tugatilgan katta ish"dan ko'ra yaxshiroq ko'rsatadi?

Nimani mustahkamlaydi: 2.1, 2.8-bo'limlar.

Xulosa

Bu darsda CLI vosita loyihasini PyPI'ga chiqarishni o'rgandik.

Eng muhim uch fikr:

1. Loyiha tuzilishi va argument. CLI loyiha tuzilishi — professional paket tartibi: src/paket/ (cli.py argument/kirish, core.py biznes logika — ajratish 27-qism), tests/ (pytest 20-qism), pyproject.toml (paketlash), README.md (hujjat), LICENSE; skript emas, tartibli. Argument tahlili (argparse/click) — CLI kirish: buyruq argumentlarini o'qish (pozitsion papka majburiy, --qoida ixtiyoriy, --test bayroq); argparse avtomatik --help beradi.

2. pyproject.toml va entry_points. pyproject.toml — zamonaviy paket konfiguratsiya: [build-system] (setuptools), [project] (metama'lumot — name, version, dependencies), [project.scripts] (entry_points); deklarativ (24-qism). entry_points — CLI sehri: pip installdan keyin terminal buyrug'I (renamer = "renamer.cli:main" — buyruq→modul:funksiya); foydalanuvchi oddiy renamer yozadi (git/docker kabi), professional vosita.

3. PyPI va bilimlarni birlashtirish. PyPI'ga chiqarish (build + twine): python -m build (paket — .whl+.tar.gz), twine upload dist/* (PyPI'ga yukla), keyin har kim pip install renamer; nom noyob, versiya semantik (har chiqarish oshir). CLI loyiha — bilimlarni birlashtirish (argument 22-qism, logika 5/16-qism, test 20-qism, paket 24-qism, ajratish 27-qism, CI 28-qism, PyPI); kichik lekin to'liq (hamma bosqich), portfolioda kuchli. "Kichik lekin to'liq" loyiha o'rganish/portfolio uchun "katta lekin chala"dan yaxshi (butun tsikl, yakunlash mahorati, ishlaydigan natija — "boshidan oxirigacha qila olaman").

Keyingi darsda Loyiha 2 — to'liq REST API + baza + auth ni quramiz: FastAPI bilan REST API, ma'lumotlar bazasi (ORM), autentifikatsiya (JWT) — real veb-xizmat qurishning to'liq amaliyoti.