30.11-dars: maturin bilan yig'ish

30-QISM — PYTHON VA BOSHQA TILLAR · 11-dars

1. Kirish va motivatsiya

PyO3 30.10-bob bilan Rust funksiyalarini #[pyfunction] orqali Python'ga ochdik. Lekin bir savol qoldi: Rust kodni qanday qilib o'rnatiladigan Python paketiga aylantiramiz? C kengaytmasida setup.py build_ext 30.6-bob bor edi. Rust+PyO3 uchun bu ish maturin vositasi bilan bo'ladi — u Rust kodni kompilyatsiya qiladi, .so/.pyd yaratadi, .whl (Python paket) qadoqlaydi, hattoki PyPI'ga chiqaradi. maturin ikki asosiy buyruq beradi: maturin develop (ishlab chiqish — modulni joyida o'rnatadi, tez sinash) va maturin build (tarqatish — .whl yaratadi). Eng muhimi: yig'ilgan .whl ichida tayyor mashina kodi bo'ladi — foydalanuvchi Rust kompilyatorini o'rnatmaydi (pip install yetadi). maturin — Rust kengaytmani tarqatishning zamonaviy, oson yo'li.

maturin — Rust+PyO3 kodini Python paketga yig'uvchi va tarqatuvchi vosita: maturin develop (ishlab chiqish — modulni joriy muhitga o'rnatadi, tez sinash), maturin build (tarqatish — .whl yaratadi), .whl (wheel) (tayyor Python paket — mashina kodi ichida, Rust kompilyatorisiz), PyPI (maturin publish — jamoaga chiqarish). Foydalanish: Rust kengaytmani o'rnatiladigan qilish, tarqatish. Bu PyO3 (30.10 — Rust'ni Python'ga) ning yig'ish qadami. Bu 30.10 (PyO3), 30.6 (setup.py — C ekvivalenti) bilan bog'liq. maturin — Rust → .whl. develop/build. Kompilyatorsiz o'rnatish.

Real vaziyat. Jamoa Rust+PyO3 kengaytmasini (30.10 — geo moduli) yozdi. Endi uni boshqa dasturchilar ishlatishi kerak edi. maturin qo'llandi: maturin develop — o'z muhitida sinadi (tez, joyida). Tayyor bo'lgach maturin build --release — geo-1.0-cp311-win_amd64.whl yaratdi (Windows uchun tayyor mashina kodi). Boshqa dasturchi pip install geo...whl — Rust o'rnatmasdan ishlatdi (.whl ichida tayyor kod). PyPI'ga maturin publish — hamma pip install geo. maturin — Rust kengaytma, oddiy pip install tajribasi.

Bu darsda maturin bilan yig'ishni o'rganamiz.

Bu darsda:

• maturin nima
• develop vs build
• .whl (wheel) — tayyor paket
• Kompilyatorsiz o'rnatish
• PyPI'ga chiqarish
• maturin amaliyoti
• maturin vs setup.py
• Amaliy: maturin oqimi modeli

ℹ maturin Rust/kompilyator talab qiladi; misollar maturin oqimi mantiqini (deterministik) modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. maturin nima

Rust'ni Python paketiga:

# maturin — Rust+PyO3 → Python paket
pip install maturin

maturin develop     # ishlab chiqish (joyida o'rnatish)
maturin build       # tarqatish (.whl yaratish)
maturin publish     # PyPI'ga chiqarish

maturin — Rust+PyO3 kodini Python paketga yig'uvchi va tarqatuvchi vosita: Rust kodni kompilyatsiya qiladi (.so/.pyd), .whl (Python paket) qadoqlaydi, PyPI'ga chiqaradi. Sabab: PyO3 30.10-bob Rust'ni Python'ga bog'laydi, lekin uni o'rnatiladigan qilish kerak (.whl); C kengaytmada setup.py 30.6-bob bu ishni qiladi, Rust+PyO3'da maturin. maturin ikki asosiy buyruq (develop — sinash, build — tarqatish). U PyO3'ga moslashgan (avtomatik topadi, kompilyatsiya). maturin — Rust → Python paket. Yig'ish, tarqatish. setup.py ekvivalenti.

2.2. develop vs build

Ikki asosiy rejim:

# DEVELOP — ishlab chiqish (tez sinash)
maturin develop
   # Rust kompilyatsiya + joriy virtualenv'ga o'rnatish
   # o'zgartir → develop → sina (tez tsikl)

# BUILD — tarqatish (.whl yaratish)
maturin build --release
   # Rust kompilyatsiya (optimallashtirilgan) + .whl
   # natija: target/wheels/*.whl

develop vs build — maturin'ning ikki asosiy rejimi: develop (ishlab chiqish — Rust kompilyatsiya + joriy virtualenvga o'rnatish, tez sinash tsikli: o'zgartir → develop → sina), build (tarqatish — Rust kompilyatsiya + .whl yaratish, --release bilan optimallashtirilgan). Sabab: ishlab chiqishda tez tsikl kerak (develop — joyida o'rnatadi, sinash), tarqatishda tayyor paket kerak (build — .whl). Farq: develop (mahalliy sinash, tez, optimallashtirilmagan), build (tarqatish, .whl, --release optimallashtirilgan). Foydalanish: o'z ishingda develop, chiqarishda build. develop — sinash (joyida). build — .whl (tarqatish). Ikki rejim.

2.3. .whl (wheel) — tayyor paket

Mashina kodli Python paket:

mening_paket-1.0-cp311-cp311-win_amd64.whl
         │    │   │        │
         │    │   │        └─ platforma (Windows 64-bit)
         │    │   └────────── Python versiyasi 3.11-bob
         │    └────────────── paket versiyasi
         └─────────────────── paket nomi

Ichida: tayyor mashina kodi (.pyd) + Python metama'lumot
   → pip install (kompilyatsiyasiz)

.whl (wheel) — Python'ning tayyor binar paket formati: ichida kompilyatsiya qilingan mashina kodi (.so/.pyd) + metama'lumot; pip install uni kompilyatsiyasiz o'rnatadi (tayyor kod). Nom: paket-versiya-python-platforma.whl (geo-1.0-cp311-win_amd64.whl — Python 3.11, Windows 64-bit). Sabab: manba paketi (kod) o'rnatishda kompilyatsiya kerak (Rust/C kompilyator — sekin, noqulay); .whl tayyor (kompilyatsiya bir marta, tarqatishda faqat nusxa). Platforma-xos (win_amd64 — har platformaga alohida .whl). maturin .whl yaratadi (2.2 build). .whl — tayyor binar paket (mashina kodi). Kompilyatsiyasiz o'rnatish. Platforma-xos.

2.4. Kompilyatorsiz o'rnatish

Foydalanuvchi Rust o'rnatmaydi:

Ishlab chiquvchi (bir marta):
   maturin build --release  →  .whl (mashina kodi)
   maturin publish          →  PyPI

Foydalanuvchi (har kim):
   pip install geo          →  .whl yuklaydi (tayyor kod)
   import geo               →  ishlaydi (Rust ko'rinmaydi)
   # Rust kompilyator KERAK EMAS

Kompilyatorsiz o'rnatish — maturin+.whlning asosiy qulayligi: ishlab chiquvchi Rust kompilyatori bilan bir marta yig'adi (build → .whl), foydalanuvchi tayyor .whlni o'rnatadi (pip install — Rust kerak emas). Sabab: agar foydalanuvchi manba o'rnatsa, Rust kompilyatori kerak bo'lardi (noqulay — hamma o'rnatmaydi, sekin); .whl bilan kompilyatsiya bir marta (ishlab chiquvchida), foydalanuvchi faqat nusxa (tez, qulay). Bu Python ekotizimining kuchi (pip install — oddiy, kengaytma ham). Cheklov: har platformaga alohida .whl (Windows, Linux, macOS — ishlab chiquvchi hammasini yig'adi, yoki CI). Kompilyatorsiz — foydalanuvchi Rust o'rnatmaydi. .whl tayyor. pip install.

2.5. PyPI'ga chiqarish

Jamoaga tarqatish:

# PyPI — Python paket ombori (hamma pip install qiladi)
maturin publish
   # .whl'larni PyPI'ga yuklaydi (barcha platformalar)
   # → pip install geo (dunyodagi har kim)

# yoki CI (GitHub Actions) — har platforma .whl avtomatik

PyPI'ga chiqarish — Rust kengaytmani jamoaga tarqatish: PyPI (Python Package Index — paket ombori, pip install shundan yuklaydi); maturin publish .whllarni PyPI'ga yuklaydi (keyin har kim pip install geo). Sabab: kengaytma foydali bo'lsa — boshqalar ishlatishi kerak (tarqatish); PyPI standart yo'l (pip install — 24-qism paketlar). Cheklov: har platforma (Windows/Linux/macOS) va Python versiya uchun alohida .whl kerak; buni CI (GitHub Actions — maturin action) avtomatlashtiradi (barcha platformalar avtomatik yig'iladi). Bu 24-qism (paket tarqatish) ning Rust kengaytma varianti. PyPI — paket ombori. maturin publish. CI barcha platforma.

2.6. maturin amaliyoti

maturin amaliyotlari: develop (ishlab chiqishda — tez sinash tsikli, joyida o'rnatish); build --release (tarqatishda — optimallashtirilgan .whl); pyproject.toml (loyiha konfiguratsiya — maturin backend); CI (GitHub Actions — barcha platforma .whl avtomatik); publish (PyPI'ga — jamoaga); versiya (semantik — 24-qism); --release unutmaslik (optimallashtirish — 30.8 Cython kabi). Tuzoqlar: develop optimallashtirilmagan (sekin — sinash uchun, tarqatishda build --release), platforma (bir .whl faqat bir platformaga), CI (qo'lda barcha platforma qiyin — avtomatlashtir). Amaliyot — develop (sinash), build --release (tarqatish), CI (platformalar). maturin — Rust kengaytma tarqatish oson.

2.7. maturin vs setup.py

maturin vs setup.py: setup.py (C kengaytma — 30.6, build_ext yig'ish, pip install -e sinash, setup.py kod konfiguratsiya), maturin (Rust+PyO3, build yig'ish, develop sinash, pyproject.toml deklarativ konfiguratsiya, PyO3'ga moslashgan). Sabab: ikkalasi ham kengaytmani .whlga yig'adi (C vs Rust), lekin maturin Rust+PyO3'ga maxsus (avtomatik topadi, oson), setup.py C uchun (umumiy setuptools). Farq: maturin zamonaviy (deklarativ pyproject.toml, PyO3 integratsiya, CI action), setup.py an'anaviy (kod). maturin Rust dunyosida standart (Cargo bilan integratsiya). maturin vs setup.py — Rust vs C yig'ish. Deklarativ vs kod. maturin PyO3'ga xos.

2.8. maturin — Rust kengaytmani tarqatish ko'prigi

maturin asosiy g'oyasi — Rust kengaytmani tarqatish ko'prigi: PyO3 30.10-bob Rust'ni Python'ga bog'laydi, maturin uni o'rnatiladigan, tarqatiladigan qiladi (.whl, PyPI). Bu Python ekotizimining kuchini (pip install — oddiy) Rust kengaytmaga olib keladi: foydalanuvchi Rust ko'rmaydi, Rust o'rnatmaydi (.whl tayyor kod — kompilyatsiya ishlab chiquvchida bir marta). maturin ish oqimi: develop (sinash) → build --release (.whl) → publish (PyPI) yoki CI (barcha platforma). Bu 30.6 (setup.py — C yig'ish) ning Rust ekvivalenti, lekin zamonaviy (deklarativ, PyO3 integratsiya). maturin PyO3'ni 30.10-bob to'liq amaliy qiladi (yozish + tarqatish). maturin — Rust kengaytma tarqatish. .whl, PyPI. Kompilyatorsiz o'rnatish.

3. Tez ma'lumotnoma

# MATURIN — Rust+PyO3 → Python paket
pip install maturin

# DEVELOP (ishlab chiqish — joyida o'rnatish, tez sinash)
maturin develop
# o'zgartir → develop → sina (tez tsikl)

# BUILD (tarqatish — .whl yaratish)
maturin build --release       # target/wheels/*.whl

# PUBLISH (PyPI'ga — jamoaga)
maturin publish

# .whl NOMI:
#   geo-1.0-cp311-cp311-win_amd64.whl
#   (nom-versiya-python-platforma)
#   ichida: tayyor mashina kodi (kompilyatsiyasiz o'rnatish)

# FOYDALANUVCHI (Rust KERAK EMAS):
#   pip install geo → import geo

# QOIDA: develop (sinash) · build --release (tarqatish) · CI (platformalar)

maturin xulosasi

maturin — Rust+PyO3 → Python paket (yig'ish, tarqatish)
develop — joyida o'rnatish (tez sinash) · build --release — .whl
.whl — tayyor mashina kodi (kompilyatsiyasiz pip install)
Foydalanuvchi Rust o'rnatmaydi (.whl tayyor kod)
PyPI (maturin publish) · CI — barcha platforma .whl avtomatik

4. Batafsil misollar

maturin Rust/kompilyator talab qiladi; misollar maturin oqimi mantiqini (deterministik) modellashtiradi.

Misol 1 — develop vs build (rejimlar)

"""develop vs build: maturin ikki rejim (model)."""


REJIMLAR = {
    "develop": {"maqsad": "ishlab chiqish (sinash)", "natija": "joriy muhitga o'rnatish", "optimal": False},
    "build --release": {"maqsad": "tarqatish", "natija": ".whl (target/wheels)", "optimal": True},
}


def main() -> None:
    print("=== 1. develop ===")
    d = REJIMLAR["develop"]
    print(f"  maqsad: {d['maqsad']}")
    print(f"  natija: {d['natija']}, optimal: {d['optimal']}")

    print("\n=== 2. build --release ===")
    b = REJIMLAR["build --release"]
    print(f"  maqsad: {b['maqsad']}")
    print(f"  natija: {b['natija']}, optimal: {b['optimal']}")

    print("\n=== 3. Tez tsikl (develop) ===")
    print("  o'zgartir → develop → sina (takroriy)")

    print("\n=== 4. Tanlov ===")
    print("  o'z ishing → develop, chiqarish → build --release")
    print("  ⭐ develop (sinash) vs build (.whl tarqatish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. develop ===
  maqsad: ishlab chiqish (sinash)
  natija: joriy muhitga o'rnatish, optimal: False

=== 2. build --release ===
  maqsad: tarqatish
  natija: .whl (target/wheels), optimal: True

=== 3. Tez tsikl (develop) ===
  o'zgartir → develop → sina (takroriy)

=== 4. Tanlov ===
  o'z ishing → develop, chiqarish → build --release
  ⭐ develop (sinash) vs build (.whl tarqatish)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — .whl nomi (tarkib)

"""'.whl' nomi: nom-versiya-python-platforma (parse modeli)."""


def whl_parse(whl: str) -> dict:
    qism = whl.replace(".whl", "").split("-")
    return {
        "nom": qism[0],
        "versiya": qism[1],
        "python": qism[2],
        "platforma": qism[-1],
    }


def main() -> None:
    whl = "geo-1.0-cp311-cp311-win_amd64.whl"

    print("=== 1. .whl fayl ===")
    print(f"  {whl}")

    print("\n=== 2. Qismlari ===")
    p = whl_parse(whl)
    print(f"  nom: {p['nom']}")
    print(f"  versiya: {p['versiya']}")
    print(f"  python: {p['python']} 3.11-bob")
    print(f"  platforma: {p['platforma']} (Windows 64-bit)")

    print("\n=== 3. Ichida ===")
    print("  tayyor mashina kodi (.pyd) + metama'lumot")

    print("\n=== 4. O'rnatish ===")
    print("  pip install (kompilyatsiyasiz — tayyor kod)")
    print("  ⭐ .whl — tayyor binar paket (platforma-xos)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. .whl fayl ===
  geo-1.0-cp311-cp311-win_amd64.whl

=== 2. Qismlari ===
  nom: geo
  versiya: 1.0
  python: cp311 3.11-bob
  platforma: win_amd64 (Windows 64-bit)

=== 3. Ichida ===
  tayyor mashina kodi (.pyd) + metama'lumot

=== 4. O'rnatish ===
  pip install (kompilyatsiyasiz — tayyor kod)
  ⭐ .whl — tayyor binar paket (platforma-xos)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Kompilyatorsiz o'rnatish (ikki tomon)

"""Kompilyatorsiz: ishlab chiquvchi vs foydalanuvchi (model)."""


def ishlab_chiquvchi() -> list:
    return [
        "Rust kod yozish (PyO3)",
        "maturin build --release (Rust kompilyator)",
        ".whl (mashina kodi)",
        "maturin publish (PyPI)",
    ]


def foydalanuvchi() -> list:
    return [
        "pip install geo (.whl yuklaydi)",
        "import geo (ishlaydi)",
        "Rust kompilyator KERAK EMAS",
    ]


def main() -> None:
    print("=== 1. Ishlab chiquvchi (bir marta) ===")
    for i, q in enumerate(ishlab_chiquvchi(), 1):
        print(f"  {i}. {q}")

    print("\n=== 2. Foydalanuvchi (har kim) ===")
    for i, q in enumerate(foydalanuvchi(), 1):
        print(f"  {i}. {q}")

    print("\n=== 3. Kalit g'oya ===")
    print("  kompilyatsiya bir marta (ishlab chiquvchida)")

    print("\n=== 4. Qulaylik ===")
    print("  pip install (oddiy) — Rust ko'rinmaydi")
    print("  ⭐ Kompilyatorsiz — foydalanuvchi Rust o'rnatmaydi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Ishlab chiquvchi (bir marta) ===
  1. Rust kod yozish (PyO3)
  2. maturin build --release (Rust kompilyator)
  3. .whl (mashina kodi)
  4. maturin publish (PyPI)

=== 2. Foydalanuvchi (har kim) ===
  1. pip install geo (.whl yuklaydi)
  2. import geo (ishlaydi)
  3. Rust kompilyator KERAK EMAS

=== 3. Kalit g'oya ===
  kompilyatsiya bir marta (ishlab chiquvchida)

=== 4. Qulaylik ===
  pip install (oddiy) — Rust ko'rinmaydi
  ⭐ Kompilyatorsiz — foydalanuvchi Rust o'rnatmaydi

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Platformalar (CI zarurati)

"""Platformalar: har platforma alohida .whl (CI model)."""


PLATFORMALAR = ["win_amd64", "manylinux_x86_64", "macosx_arm64"]
PYTHON_VERSIYALAR = ["cp311", "cp312"]


def whl_royxati(nom: str, versiya: str) -> list:
    natija = []
    for p in PLATFORMALAR:
        for py in PYTHON_VERSIYALAR:
            natija.append(f"{nom}-{versiya}-{py}-{py}-{p}.whl")
    return natija


def main() -> None:
    whllar = whl_royxati("geo", "1.0")

    print("=== 1. Platformalar ===")
    for p in PLATFORMALAR:
        print(f"  {p}")

    print("\n=== 2. Kerakli .whl'lar ===")
    print(f"  jami: {len(whllar)} ta (platforma × python)")
    for w in whllar[:3]:
        print(f"  {w}")
    print("  ...")

    print("\n=== 3. Qo'lda qiyin ===")
    print(f"  {len(whllar)} ta .whl qo'lda yig'ish (noqulay)")

    print("\n=== 4. Yechim: CI ===")
    print("  GitHub Actions (maturin action) — avtomatik")
    print("  ⭐ CI — barcha platforma .whl avtomatik")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Platformalar ===
  win_amd64
  manylinux_x86_64
  macosx_arm64

=== 2. Kerakli .whl'lar ===
  jami: 6 ta (platforma × python)
  geo-1.0-cp311-cp311-win_amd64.whl
  geo-1.0-cp312-cp312-win_amd64.whl
  geo-1.0-cp311-cp311-manylinux_x86_64.whl
  ...

=== 3. Qo'lda qiyin ===
  6 ta .whl qo'lda yig'ish (noqulay)

=== 4. Yechim: CI ===
  GitHub Actions (maturin action) — avtomatik
  ⭐ CI — barcha platforma .whl avtomatik

Nima ko'rsatdi: 2.5-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. build --release unutish

maturin build   # optimallashtirilmagan (sekin)              # ⚠️
maturin build --release   # optimallashtirilgan               # ✅

2. develop bilan tarqatish

# develop natijasini tarqatish (joyida o'rnatilgan)           # ⚠️
maturin build --release → .whl (tarqatish)                    # ✅

3. Bir platforma .whl'ni hamma uchun

# win_amd64.whl'ni Linux'ga (ishlamaydi)                      # ⚠️
# har platforma alohida .whl (CI)                              # ✅

4. Foydalanuvchiga Rust o'rnatish

# foydalanuvchi Rust o'rnatsin (noqulay)                      # ⚠️
# .whl tayyor (pip install — Rust kerak emas)                  # ✅

5. Qo'lda barcha platforma

# har platformada qo'lda build (uzoq, xato)                   # ⚠️
# CI (GitHub Actions — maturin action)                         # ✅

6. pyproject.toml sozlamasiz

# maturin backend ko'rsatilmagan                              # ⚠️
# pyproject.toml [build-system] maturin                        # ✅

7. Versiya boshqarmaslik

# har build bir xil versiya (chalkashlik)                     # ⚠️
# semantik versiya (24-qism — 1.0, 1.1)                        # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 30.10-dars (o'tilgan): PyO3 — Rust modul (maturin yig'adi)
• 30.9-dars (o'tilgan): Rust — nega Python bilan
• 30.6-dars (o'tilgan): setup.py — C ekvivalenti
• 24-qism (o'tilgan): Paket va PyPI
• 28.7-dars (o'tilgan): CI/CD — platforma avtomatik

8. Eng yaxshi amaliyotlar

1. develop (sinash), build --release (tarqatish).

2. --release unutmaslik (optimallashtirish).

3. .whl (tayyor kod — foydalanuvchi Rust'siz).

4. CI (barcha platforma .whl avtomatik).

5. pyproject.toml (maturin backend).

6. PyPI (maturin publish — jamoaga).

7. Semantik versiya (24-qism).

8. Har platforma alohida .whl (win/linux/macos).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # maturin nima?
2.  # maturin nimaga kerak?
3.  # develop nima?
4.  # build nima?
5.  # develop vs build?
6.  # .whl nima?
7.  # .whl ichida nima?
8.  # foydalanuvchi Rust o'rnatadimi?
9.  # nega kompilyatorsiz?
10. # PyPI nima?
11. # nega CI?
12. # maturin vs setup.py?

Vazifa 2: Xatolarni tuzating

1.  maturin build   # tarqatish uchun

2.  # develop natijasini tarqatish

3.  # win_amd64.whl'ni Linux'ga

4.  # foydalanuvchi Rust o'rnatsin

5.  # har platformada qo'lda build

1.  maturin build --release

2.  maturin build --release (.whl)

3.  har platforma alohida .whl

4.  .whl tayyor (Rust kerak emas)

5.  CI (maturin action)

Vazifa 3: Rejimlar

Modellang:

1. develop
2. build
3. Maqsad
4. Tanlov

Vazifa 4: .whl

Modellang:

1. Nom
2. Platforma
3. Ichi
4. O'rnatish

Vazifa 5: Kompilyatorsiz

Modellang:

1. Ishlab chiquvchi
2. Foydalanuvchi
3. Bir marta
4. pip install

Vazifa 6: Platformalar

Modellang:

1. Platformalar
2. .whl'lar
3. Qo'lda qiyin
4. CI

Vazifa 7: O'ylash

maturin .whl yaratadi — kompilyatsiya bir marta (ishlab chiquvchida) bo'ladi, foydalanuvchi tayyor kodni oladi (pip install, Rust kerak emas). Nima uchun "og'ir ishni bir marta oldindan qilish" (yig'ish vaqtida — build-time) "har foydalanishda takrorlash"dan (o'rnatish vaqtida — install-time) yaxshiroq, va bu qanday umumiy muhandislik naqshi (oldindan hisoblash)?

Nimani mustahkamlaydi: 2.3, 2.4-bo'limlar.

Xulosa

Bu darsda maturin bilan yig'ishni o'rgandik.

Eng muhim uch fikr:

1. maturin va develop/build. maturin — Rust+PyO3 kodini Python paketga yig'uvchi va tarqatuvchi vosita: Rust kodni kompilyatsiya (.so/.pyd), .whl qadoqlash, PyPI'ga chiqarish; C kengaytmadagi setup.py 30.6-bob ning Rust ekvivalenti (PyO3'ga moslashgan). develop vs build: develop (ishlab chiqish — Rust kompilyatsiya + joriy virtualenvga o'rnatish, tez sinash tsikli), build --release (tarqatish — optimallashtirilgan .whl); o'z ishingda develop, chiqarishda build.

2. .whl va kompilyatorsiz o'rnatish. .whl (wheel) — Python'ning tayyor binar paket formati: ichida kompilyatsiya qilingan mashina kodi + metama'lumot; pip install kompilyatsiyasiz o'rnatadi; nom paket-versiya-python-platforma.whl (geo-1.0-cp311-win_amd64.whl), platforma-xos. Kompilyatorsiz o'rnatish — asosiy qulaylik: ishlab chiquvchi bir marta yig'adi (build → .whl), foydalanuvchi tayyor .whlni o'rnatadi (pip install — Rust kerak emas); kompilyatsiya bir marta (ishlab chiquvchida), foydalanuvchi faqat nusxa.

3. PyPI, CI va tarqatish ko'prigi. PyPI'ga chiqarish — maturin publish .whllarni PyPI'ga yuklaydi (har kim pip install geo); har platforma (Windows/Linux/macOS) va Python versiya uchun alohida .whl kerak, buni CI (GitHub Actions — maturin action) avtomatlashtiradi. maturin vs setup.py: maturin (Rust+PyO3, pyproject.toml deklarativ, zamonaviy), setup.py (C, kod). maturin — Rust kengaytmani tarqatish ko'prigi (PyO3'ni o'rnatiladigan/tarqatiladigan qiladi); og'ir ishni (kompilyatsiya) bir marta oldindan qilish (build-time), foydalanuvchi tayyor oladi — oldindan hisoblash naqshi (kesh, indeks, CDN kabi, narx amortizatsiya).

Keyingi darsda C++ va pybind11 ni o'rganamiz: C++ kodini Python'ga bog'lash — pybind11 kutubxonasi (PyO3'ning C++ ekvivalenti), zamonaviy C++ imkoniyatlari va C++ kutubxonalarini Python'da ishlatish.