12.7-dars: Alternativ interpretatorlar: PyPy, MicroPython

with open(yol) as f:        # ✅ aniq yopish — hamma joyda ishlaydi
    matn = f.read()

matn = open(yol).read()     # ❌ CPython'da ishlaydi, PyPy'da deskriptor qoladi

sys.implementation.name          # 'cpython', 'pypy', 'micropython', 'graalpy'
sys.implementation.version       # implementatsiya versiyasi
platform.python_implementation() # 'CPython', 'PyPy', ...
sys.version_info                 # til versiyasi (hammasida bor)

if sys.implementation.name == "cpython":     # ❌ mo'rt
    ...
if hasattr(sys, "getrefcount"):              # ✅ imkoniyat bo'yicha
    ...
try:
    import ujson as json                     # ✅ muqobil bilan
except ImportError:
    import json

sys.implementation.name / .version      platform.python_implementation()
hasattr(sys, "getrefcount")             try: import X except ImportError: ...

with / finalize  →  refcount ga tayanmang
==               →  is (qiymatlar uchun) o'rniga
qulflar          →  GIL atomarligiga tayanmang
id()             →  faqat identifikator, manzil emas
sys.getsizeof, ctypes, gc tafsilotlari → CPython'ga xos

CPython (etalon) · PyPy (JIT, sof Python) · MicroPython (mikrokontroller)
GraalPy (JVM) · Pyodide (brauzer) · Cython/Nuitka (kompilyatorlar)

"""sys.implementation va platform; imkoniyatlarni tekshirish; nom bo'yicha emas, imkoniyat bo'yicha tarmoqlanish."""

import platform
import sys


def bor(nom, tekshiruv):
    try:
        return "✅" if tekshiruv() else "❌"
    except Exception:
        return "❌"


print("=== 1. Implementatsiya ===")
print(f"  sys.implementation.name: {sys.implementation.name}")
print(f"  platform.python_implementation(): {platform.python_implementation()}")
print(f"  til versiyasi: {'.'.join(map(str, sys.version_info[:3]))}")
print(f"  implementatsiya versiyasi ham bor: {hasattr(sys.implementation, 'version')}")
print(f"  cache_tag: {sys.implementation.cache_tag}")

print("\n=== 2. Imkoniyatlar (boshqa implementatsiyalarda farq qiladi) ===")
IMKONIYATLAR = {
    "sys.getrefcount": lambda: sys.getrefcount(object()) > 0,
    "sys._getframe": lambda: sys._getframe() is not None,
    "sys.getsizeof": lambda: sys.getsizeof(1) > 0,
    "sys._is_gil_enabled": lambda: sys._is_gil_enabled() in (True, False),
    "ctypes": lambda: __import__("ctypes").sizeof(__import__("ctypes").c_void_p) > 0,
    "gc.get_referrers": lambda: isinstance(__import__("gc").get_referrers(object()), list),
    "threading": lambda: __import__("threading").active_count() >= 1,
    "dataclasses": lambda: __import__("dataclasses").is_dataclass(object) is False,
    "decimal (C tezkor)": lambda: __import__("decimal").__file__ is not None,
}
for nom, tekshiruv in IMKONIYATLAR.items():
    print(f"  {nom:22} {bor(nom, tekshiruv)}")

print("\n=== 3. Nom bo'yicha emas, imkoniyat bo'yicha ===")


def tirikmi(obj_havola):
    """Obyekt tirikligini har joyda ishlaydigan usulda tekshirish."""
    return obj_havola() is not None


def xotira_hisoboti(obj):
    if hasattr(sys, "getsizeof"):
        return f"{sys.getsizeof(obj)} bayt"
    return "o'lchov mavjud emas (masalan, MicroPython)"


import weakref


class Yozuv:
    pass


y = Yozuv()
havola = weakref.ref(y)
print(f"  weakref bilan tirikligi: {tirikmi(havola)}")
del y
print(f"  o'chirilgandan keyin: {tirikmi(havola)}  ← CPython'da darhol, boshqa joyda GC dan keyin")
print(f"  xotira hisoboti: {xotira_hisoboti([1, 2, 3])}")
print(f"  JSON kutubxonasi: {'ujson' if 'ujson' in sys.modules else 'json'} (MicroPython'da ujson bo'lishi mumkin)")

=== 1. Implementatsiya ===
  sys.implementation.name: cpython
  platform.python_implementation(): CPython
  til versiyasi: 3.14.5
  implementatsiya versiyasi ham bor: True
  cache_tag: cpython-314

=== 2. Imkoniyatlar (boshqa implementatsiyalarda farq qiladi) ===
  sys.getrefcount        ✅
  sys._getframe          ✅
  sys.getsizeof          ✅
  sys._is_gil_enabled    ✅
  ctypes                 ✅
  gc.get_referrers       ✅
  threading              ✅
  dataclasses            ✅
  decimal (C tezkor)     ✅

=== 3. Nom bo'yicha emas, imkoniyat bo'yicha ===
  weakref bilan tirikligi: True
  o'chirilgandan keyin: False  ← CPython'da darhol, boshqa joyda GC dan keyin
  xotira hisoboti: 88 bayt
  JSON kutubxonasi: json (MicroPython'da ujson bo'lishi mumkin)

"""__del__ vaqti: refcount va GC; sikl orqali 'PyPy kabi' kechikishni ko'rsatish; id(), interning, GIL atomarligi; to'g'ri yozish usullari."""

import gc
import sys
import weakref


jurnal = []


class Fayl:
    """Resursni __del__ da yopadigan (yomon) sinf."""

    def __init__(self, nom):
        self.nom = nom
        jurnal.append(f"ochildi:{nom}")

    def __del__(self):
        jurnal.append(f"yopildi:{self.nom}")


print("=== 1. __del__ qachon ishlaydi ===")
f = Fayl("hisobot.csv")
del f
print(f"  refcount nolga tushdi → darhol: {jurnal}")

jurnal.clear()
a, b = Fayl("a.log"), Fayl("b.log")
a.juft, b.juft = b, a          # sikl: refcount yetarli emas
del a, b
print(f"  sikl ichida, gc.collect() dan oldin: {[x for x in jurnal if x.startswith('yopildi')]}")
gc.collect()
print(f"  gc.collect() dan keyin: {[x for x in jurnal if x.startswith('yopildi')]}")
print("  ⭐ PyPy va GraalPy'da refcount yo'q — oddiy holat ham shunday 'kechikadi'")

print("\n=== 2. Ko'chuvchan yechim ===")
jurnal.clear()


class Xavfsiz:
    def __init__(self, nom):
        self.nom = nom
        jurnal.append(f"ochildi:{nom}")

    def yop(self):
        if self.nom:
            jurnal.append(f"yopildi:{self.nom}")
            self.nom = None

    def __enter__(self):
        return self

    def __exit__(self, *xato):
        self.yop()
        return False


with Xavfsiz("tranzaksiya.db") as x:
    pass
print(f"  with bloki: {jurnal}  ← implementatsiyadan qat'i nazar aniq vaqtda")
jurnal.clear()
x = Xavfsiz("kesh.bin")
weakref.finalize(x, jurnal.append, "yopildi:kesh.bin (finalize)")
del x
print(f"  weakref.finalize zaxira sifatida: {jurnal}")

print("\n=== 3. Boshqa farazlar ===")
s1 = "".join(["so", "liq"])
s2 = "soliq"
print(f"  id() — CPython'da manzil: {id(s2) > 0}, lekin ma'nosi implementatsiyaga bog'liq")
print(f"  ish vaqtidagi satr konstanta bilan bitta obyektmi: {s1 is s2} (11.7-dars), teng: {s1 == s2}")
print(f"  {'✅ == ishlatildi' if s1 == s2 else ''} — 'is' ni qiymat uchun ishlatmang")
kichik = 256
print(f"  kichik sonlar keshi CPython tafsiloti: {kichik is int('256')}")
print(f"  sys.getrefcount mavjud: {hasattr(sys, 'getrefcount')} — PyPy'da yo'q, kod unga tayanmasin")
print("  list.append atomarligi GIL ga bog'liq 12.5-bob — qulf ishlating")

=== 1. __del__ qachon ishlaydi ===
  refcount nolga tushdi → darhol: ['ochildi:hisobot.csv', 'yopildi:hisobot.csv']
  sikl ichida, gc.collect() dan oldin: []
  gc.collect() dan keyin: ['yopildi:a.log', 'yopildi:b.log']
  ⭐ PyPy va GraalPy'da refcount yo'q — oddiy holat ham shunday 'kechikadi'

=== 2. Ko'chuvchan yechim ===
  with bloki: ['ochildi:tranzaksiya.db', 'yopildi:tranzaksiya.db']  ← implementatsiyadan qat'i nazar aniq vaqtda
  weakref.finalize zaxira sifatida: ['ochildi:kesh.bin', 'yopildi:kesh.bin (finalize)']

=== 3. Boshqa farazlar ===
  id() — CPython'da manzil: True, lekin ma'nosi implementatsiyaga bog'liq
  ish vaqtidagi satr konstanta bilan bitta obyektmi: False (11.7-dars), teng: True
  ✅ == ishlatildi — 'is' ni qiymat uchun ishlatmang
  kichik sonlar keshi CPython tafsiloti: True
  sys.getrefcount mavjud: True — PyPy'da yo'q, kod unga tayanmasin
  list.append atomarligi GIL ga bog'liq 12.5-bob — qulf ishlating

"""AST bilan manbani tekshirish: CPython'ga xos API lar, xavfli naqshlar va MicroPython'da yo'q modullar."""

import ast

CPYTHON_API = {
    "sys.getrefcount": "havolalar sanog'i — faqat CPython",
    "sys._getframe": "freymlar — PyPy'da cheklangan",
    "sys.getsizeof": "MicroPython'da yo'q",
    "ctypes.pythonapi": "C API — faqat CPython",
    "gc.get_referrers": "GC tafsiloti — implementatsiyaga bog'liq",
    "gc.get_objects": "GC tafsiloti",
}

MICROPYTHON_YOQ = {"pandas", "numpy", "inspect", "dataclasses", "typing", "sqlite3", "multiprocessing", "concurrent"}


class Tekshiruvchi(ast.NodeVisitor):
    def __init__(self):
        self.topilmalar = []

    def qayd(self, tugun, tur, matn):
        self.topilmalar.append((tugun.lineno, tur, matn))

    def visit_Attribute(self, tugun):
        nom = ast.unparse(tugun)
        if nom in CPYTHON_API:
            self.qayd(tugun, "CPython API", f"{nom} — {CPYTHON_API[nom]}")
        self.generic_visit(tugun)

    def visit_Import(self, tugun):
        for a in tugun.names:
            if a.name.split(".")[0] in MICROPYTHON_YOQ:
                self.qayd(tugun, "MicroPython'da yo'q", a.name)
        self.generic_visit(tugun)

    def visit_ImportFrom(self, tugun):
        if tugun.module and tugun.module.split(".")[0] in MICROPYTHON_YOQ:
            self.qayd(tugun, "MicroPython'da yo'q", tugun.module)
        self.generic_visit(tugun)

    def visit_Compare(self, tugun):
        for op, tomon in zip(tugun.ops, tugun.comparators):
            if isinstance(op, (ast.Is, ast.IsNot)) and isinstance(tomon, ast.Constant) and tomon.value is not None:
                self.qayd(tugun, "is bilan qiymat", f"{ast.unparse(tugun)} — == ishlating 11.2-bob")
        self.generic_visit(tugun)

    def visit_FunctionDef(self, tugun):
        if tugun.name == "__del__":
            self.qayd(tugun, "__del__ ga tayanish", "resursni with yoki weakref.finalize bilan yoping")
        self.generic_visit(tugun)

    def visit_Call(self, tugun):
        # open(...).read() — fayl aniq yopilmaydi
        if isinstance(tugun.func, ast.Attribute) and isinstance(tugun.func.value, ast.Call):
            ichki = tugun.func.value.func
            if isinstance(ichki, ast.Name) and ichki.id == "open" and tugun.func.attr in {"read", "readlines", "write"}:
                self.qayd(tugun, "yopilmagan fayl", f"{ast.unparse(tugun)[:40]} — with ishlating")
        self.generic_visit(tugun)


MANBA = '''
import sys, gc, ctypes
import pandas as pd
from dataclasses import dataclass

def kesh_hajmi(kesh):
    return sys.getsizeof(kesh)

def nusxalar(obj):
    return sys.getrefcount(obj) - 1

class Ulanish:
    def __del__(self):
        self.soket.close()

def sozlama_oqi(yol):
    matn = open(yol).read()
    if matn is "":
        return {}
    return matn

def freym():
    return sys._getframe(1).f_code.co_name
'''

daraxt = ast.parse(MANBA)
tekshiruvchi = Tekshiruvchi()
tekshiruvchi.visit(daraxt)

print("=== Ko'chuvchanlik hisoboti ===")
for qator, tur, matn in sorted(tekshiruvchi.topilmalar):
    print(f"  qator {qator:>2}  {tur:22} {matn}")
print(f"\n  jami: {len(tekshiruvchi.topilmalar)} ta ogohlantirish")
turlar = {}
for _, tur, _ in tekshiruvchi.topilmalar:
    turlar[tur] = turlar.get(tur, 0) + 1
print(f"  turlar bo'yicha: {dict(sorted(turlar.items()))}")

=== Ko'chuvchanlik hisoboti ===
  qator  3  MicroPython'da yo'q    pandas
  qator  4  MicroPython'da yo'q    dataclasses
  qator  7  CPython API            sys.getsizeof — MicroPython'da yo'q
  qator 10  CPython API            sys.getrefcount — havolalar sanog'i — faqat CPython
  qator 13  __del__ ga tayanish    resursni with yoki weakref.finalize bilan yoping
  qator 17  yopilmagan fayl        open(yol).read() — with ishlating
  qator 18  is bilan qiymat        matn is '' — == ishlating 11.2-bob
  qator 23  CPython API            sys._getframe — freymlar — PyPy'da cheklangan

  jami: 8 ta ogohlantirish
  turlar bo'yicha: {'CPython API': 3, "MicroPython'da yo'q": 2, '__del__ ga tayanish': 1, 'is bilan qiymat': 1, 'yopilmagan fayl': 1}

"""Muhit qatlamini imkoniyatlar bo'yicha qurish; MicroPython uslubidagi cheklangan muhitni taqlid qilib sinash."""

import sys


def muhit_yasa(mavjud_modullar=None, imkoniyatlar=None):
    """mavjud_modullar=None — haqiqiy muhit; aks holda taqlid (simulyatsiya)."""
    haqiqiy = mavjud_modullar is None
    bor = (lambda nom: nom in sys.modules or _import_mumkinmi(nom)) if haqiqiy else (lambda nom: nom in mavjud_modullar)
    imkon = (lambda nom: hasattr(sys, nom)) if haqiqiy else (lambda nom: nom in (imkoniyatlar or set()))
    return {
        "nom": sys.implementation.name if haqiqiy else "taqlid",
        "json": "json" if bor("json") else ("ujson" if bor("ujson") else "yo'q"),
        "vaqt_aniqligi": "ns" if imkon("_getframe") and bor("time") else "s",
        "xotira_olchovi": bool(imkon("getsizeof")),
        "iplar": bor("threading"),
        "saqlash": "sqlite3" if bor("sqlite3") else "fayl",
    }


def _import_mumkinmi(nom):
    try:
        __import__(nom)
        return True
    except ImportError:
        return False


class Yigʻuvchi:
    """Muhitga moslashadigan sensor yig'uvchi."""

    def __init__(self, muhit, bufer_hajmi=4):
        self.muhit = muhit
        self.bufer = []
        self.bufer_hajmi = bufer_hajmi
        self.yozilgan = []

    def olch(self, qiymat):
        self.bufer.append(round(qiymat, 2))
        if len(self.bufer) >= self.bufer_hajmi:
            self.yuborish()

    def yuborish(self):
        if not self.bufer:
            return
        if self.muhit["json"] != "yo'q":
            import json
            yuk = json.dumps({"qiymatlar": self.bufer})
        else:
            yuk = "|".join(str(q) for q in self.bufer)      # JSON bo'lmasa — oddiy format
        self.yozilgan.append((self.muhit["saqlash"], yuk))
        self.bufer = []          # yangi ro'yxat emas, tozalash ham mumkin — MicroPython'da xotira muhim


SERVER = None
MIKRO = ({"ujson", "time", "machine"}, set())
BRAUZER = ({"json", "time", "asyncio"}, {"getsizeof"})
MINIMAL = ({"time", "machine"}, set())          # JSON umuman yo'q port

print("=== 1. Muhitlar ===")
muhitlar = {
    "CPython (haqiqiy)": muhit_yasa(),
    "MicroPython (taqlid)": muhit_yasa(*MIKRO),
    "Pyodide (taqlid)": muhit_yasa(*BRAUZER),
    "Minimal port (taqlid)": muhit_yasa(*MINIMAL),
}
for nom, m in muhitlar.items():
    print(f"  {nom:22} json={m['json']:5} xotira_olchovi={str(m['xotira_olchovi']):5} iplar={str(m['iplar']):5} saqlash={m['saqlash']}")

print("\n=== 2. Bir xil kod, to'rt muhit ===")
for nom, m in muhitlar.items():
    yigʻuvchi = Yigʻuvchi(m)
    for i in range(6):
        yigʻuvchi.olch(20 + i * 0.75)
    yigʻuvchi.yuborish()
    print(f"  {nom:22} {len(yigʻuvchi.yozilgan)} paket, birinchisi: {yigʻuvchi.yozilgan[0][1][:44]}")

print("\n=== 3. Qaysi qismlar ko'chuvchan emas ===")
tekshiruvlar = [
    ("sys.getsizeof bilan bufer hajmi", hasattr(sys, "getsizeof")),
    ("threading bilan fon yuborish", _import_mumkinmi("threading")),
    ("sqlite3 bilan saqlash", _import_mumkinmi("sqlite3")),
    ("f-string va dataclass", sys.version_info >= (3, 7)),
]
for tavsif, mavjud in tekshiruvlar:
    holat = "bor" if mavjud else "yoq"
    print(f"  {tavsif:34} CPython muhitida {holat}; cheklangan muhitda muqobil kerak")

=== 1. Muhitlar ===
  CPython (haqiqiy)      json=json  xotira_olchovi=True  iplar=True  saqlash=sqlite3
  MicroPython (taqlid)   json=ujson xotira_olchovi=False iplar=False saqlash=fayl
  Pyodide (taqlid)       json=json  xotira_olchovi=True  iplar=False saqlash=fayl
  Minimal port (taqlid)  json=yo'q  xotira_olchovi=False iplar=False saqlash=fayl

=== 2. Bir xil kod, to'rt muhit ===
  CPython (haqiqiy)      2 paket, birinchisi: {"qiymatlar": [20.0, 20.75, 21.5, 22.25]}
  MicroPython (taqlid)   2 paket, birinchisi: {"qiymatlar": [20.0, 20.75, 21.5, 22.25]}
  Pyodide (taqlid)       2 paket, birinchisi: {"qiymatlar": [20.0, 20.75, 21.5, 22.25]}
  Minimal port (taqlid)  2 paket, birinchisi: 20.0|20.75|21.5|22.25

=== 3. Qaysi qismlar ko'chuvchan emas ===
  sys.getsizeof bilan bufer hajmi    CPython muhitida bor; cheklangan muhitda muqobil kerak
  threading bilan fon yuborish       CPython muhitida bor; cheklangan muhitda muqobil kerak
  sqlite3 bilan saqlash              CPython muhitida bor; cheklangan muhitda muqobil kerak
  f-string va dataclass              CPython muhitida bor; cheklangan muhitda muqobil kerak

def oqi(yol):
    return open(yol).read()                 # ❌ PyPy'da deskriptor ochiq qoladi
with open(yol) as f:
    return f.read()                         # ✅

if sys.getrefcount(obj) == 2:               # ❌ boshqa implementatsiyada yo'q
if havola() is None:                        # ✅ weakref

if javob is "ha":                           # ❌
if javob == "ha":                           # ✅

self.hisob += 1                             # ❌ boshqa implementatsiyada va erkin ipli yig'mada
with self.qulf:
    self.hisob += 1                         # ✅

pypy skript.py                              # ⚠️ isitish ulgurmaydi — noto'g'ri xulosa

import pandas as pd                          # ❌ mikrokontrollerda yo'q

# ⚠️ cpyext orqali ishlaydi, lekin sekin — muqobil sof Python kutubxona qidiring

korsatkich = id(obj)                        # ❌ faqat CPython'da manzil

import sys
import platform
1.  print(sys.implementation.name)
2.  print(platform.python_implementation())
3.  print(sys.implementation.name == platform.python_implementation().lower())
4.  print(hasattr(sys, "getrefcount"))
5.  print(sys.implementation.cache_tag.startswith("cpython"))
6.  print(type(sys.implementation.version).__name__)
7.  print(sys.version_info >= (3, 11))
8.  try:
        import ujson
        print("ujson")
    except ImportError:
        print("json")
9.  print(hasattr(sys, "_getframe"), hasattr(sys, "getsizeof"))
10. class K:
        pass
    k = K()
    print(id(k) == id(k))
11. import gc
    print(gc.isenabled())
12. print("pypy" in sys.version.lower())

1.  class Ulanish:
        def __init__(self, manzil):
            self.s = ochish(manzil)
        def __del__(self):
            self.s.close()

2.  def sozlama():
        matn = open("sozlama.json").read()
        return json.loads(matn)

3.  def implementatsiya_tekshir():
        if sys.implementation.name != "cpython":
            raise RuntimeError("faqat CPython")
        return sys.getsizeof(KESH)

4.  def kutubxona_yukla():
        import numpy as np
        return np.zeros(1000)          # MicroPython uchun ham mo'ljallangan modul

5.  hisoblagich = 0
    def oshir():
        global hisoblagich
        hisoblagich += 1               # ko'p ipli xizmat