O'z ma'lumotingni yig'ish: scraping va API

import pandas as pd
show(pd.DataFrame([
    {"Yo'l": "1. Rasmiy API", "Sifati": "Eng yaxshi",
     "Izoh": "Struktura toza, shartlar aniq, buzilmaydi"},
    {"Yo'l": "2. Ochiq ma'lumot / eksport", "Sifati": "Yaxshi",
     "Izoh": "stat.uz, data.gov.uz, saytning CSV eksporti"},
    {"Yo'l": "3. Hamkorlik so'rash", "Sifati": "Yaxshi",
     "Izoh": "Ko'pincha ishlaydi — shunchaki so'rang. Bepul va qonuniy"},
    {"Yo'l": "4. Scraping", "Sifati": "Oxirgi chora",
     "Izoh": "Sayt o'zgarsa buziladi; huquqiy javobgarlik sizda"},
]))

from pathlib import Path
FIX = DATA / "fixture"
for p in sorted(FIX.iterdir()):
    print(f"  {p.name:<18} {p.stat().st_size:>6} bayt")
print()
xom = (FIX / "elonlar_1.html").read_text(encoding="utf-8")
print("Birinchi e'lon bloki qanday ko'rinadi:")
bosh = xom.index('<div class="elon"')
print(xom[bosh:bosh + 560])

from bs4 import BeautifulSoup

sup = BeautifulSoup(xom, "html.parser")
elonlar = sup.select("div.elon")
print(f"1-sahifada topilgan e'lonlar: {len(elonlar)}")
print()
birinchi = elonlar[0]
print(f"  data-id  : {birinchi['data-id']}")
print(f"  sarlavha : {birinchi.select_one('h3.sarlavha').get_text(strip=True)}")
print(f"  narx     : {birinchi.select_one('div.narx').get_text(strip=True)}")
print(f"  tuman    : {birinchi.select_one('span.tuman').get_text(strip=True)}")
xona = birinchi.select_one("span.xona")
print(f"  xona     : {xona.get_text(strip=True) if xona else 'YO`Q'}")

"""Yig'uvdan OLDIN tekshiriladigan qoidalar."""
import urllib.parse
import urllib.request
import urllib.robotparser

ARIZA = "MLKitobTalaba/1.0 (+o'quv loyihasi; aloqa: talaba@example.uz)"


def ruxsat_bormi(url, agent=ARIZA):
    """robots.txt ga ko'ra shu URL ni olish mumkinmi.

    Diqqat: robots.txt ruxsat bergani ToS ruxsat berganini BILDIRMAYDI.
    Shartlarni odam o'qishi kerak, kod emas.
    """
    qism = urllib.parse.urlparse(url)
    rp = urllib.robotparser.RobotFileParser()
    rp.set_url(f"{qism.scheme}://{qism.netloc}/robots.txt")
    try:
        rp.read()
    except Exception:
        return False            # robots.txt o'qilmasa — RUXSAT YO'Q deb hisoblaymiz
    return rp.can_fetch(agent, url)


SHAXSIY = {"tel", "telefon", "phone", "ism", "name", "email", "manzil", "address"}


def shaxsiyni_tashla(yozuv):
    """Shaxsiy maydonlarni yozuvdan olib tashlaydi.

    Yig'uvning OXIRIDA emas, BOSHIDA chaqiriladi: diskka yozilmagan
    ma'lumot o'g'irlanmaydi.
    """
    return {k: v for k, v in yozuv.items() if k.lower() not in SHAXSIY}

"""Sekin, kechiradigan va keshlaydigan yuklab oluvchi."""
import hashlib
import time
import urllib.request
from pathlib import Path

KESH = Path("kesh")
KECHIKISH = 1.0          # soniyada bitta so'rov
URINISH = 3


def _kesh_yoli(url):
    return KESH / (hashlib.sha256(url.encode()).hexdigest()[:16] + ".html")


def ol(url, agent="MLKitobTalaba/1.0", majburlab=False):
    """URL matnini qaytaradi. Bir marta yuklab olinadi, keyin keshdan.

    Kesh — xushmuomilalikning asosiy qismi: kodni 50 marta ishga tushirsangiz
    ham sayt bitta so'rov oladi.
    """
    KESH.mkdir(exist_ok=True)
    yol = _kesh_yoli(url)
    if yol.exists() and not majburlab:
        return yol.read_text(encoding="utf-8"), "kesh"

    oxirgi_xato = None
    for urinish in range(1, URINISH + 1):
        try:
            soro = urllib.request.Request(url, headers={"User-Agent": agent})
            with urllib.request.urlopen(soro, timeout=20) as javob:
                matn = javob.read().decode("utf-8", errors="replace")
            yol.write_text(matn, encoding="utf-8")
            time.sleep(KECHIKISH)
            return matn, "tarmoq"
        except Exception as x:
            oxirgi_xato = x
            time.sleep(KECHIKISH * 2 ** urinish)     # eksponensial kutish
    raise RuntimeError(f"{URINISH} urinishdan keyin olinmadi: {url}") from oxirgi_xato

"""HTML -> yozuvlar. Hech qanday tozalash YO'Q — xom holda saqlanadi."""
from bs4 import BeautifulSoup

from .qoidalar import shaxsiyni_tashla


def matn(blok, selektor):
    """Yo'q bo'lsa None qaytaradi — AttributeError emas."""
    topildi = blok.select_one(selektor)
    return topildi.get_text(strip=True) if topildi else None


def sahifani_tahlil(html_matn):
    sup = BeautifulSoup(html_matn, "html.parser")
    natija = []
    for blok in sup.select("div.elon"):
        yozuv = {
            "manba_id": blok.get("data-id"),
            "sarlavha": matn(blok, "h3.sarlavha"),
            "narx_xom": matn(blok, "div.narx"),
            "xona_xom": matn(blok, "span.xona"),
            "maydon_xom": matn(blok, "span.maydon"),
            "tuman": matn(blok, "span.tuman"),
            "qavat_xom": matn(blok, "span.qavat"),
            "tel": matn(blok, "div.aloqa"),          # yig'iladi, lekin SAQLANMAYDI
        }
        natija.append(shaxsiyni_tashla(yozuv))
    return natija

import sys
sys.path.insert(0, str(ISH))
from yiguv.tahlil import sahifani_tahlil

sahifalar = sorted(FIX.glob("elonlar_*.html"))
yozuvlar = []
for sah_yoli in sahifalar:
    bu = sahifani_tahlil(sah_yoli.read_text(encoding="utf-8"))
    yozuvlar += bu
    if sah_yoli is sahifalar[0] or sah_yoli is sahifalar[-1]:
        print(f"  {sah_yoli.name} -> {len(bu)} yozuv")
print(f"  ... jami {len(sahifalar)} sahifa o'qildi")
xom_df = pd.DataFrame(yozuvlar)
print(f"\nJami: {len(xom_df)} yozuv, {len(xom_df.columns)} ustun")
print(f"Ustunlar: {list(xom_df.columns)}")
print()
print(f"Telefon ustuni bormi? {'tel' in xom_df.columns}  <- shaxsiyni_tashla() ishladi")
show(xom_df.head(6))

buzilgan = (FIX / "elonlar_3.html").read_text(encoding="utf-8")
print(f"3-sahifada yopilmagan <div> bor: {buzilgan.count('<div')} ochildi, {buzilgan.count('</div>')} yopildi")
print(f"Shunga qaramay topilgan e'lon: {len(sahifani_tahlil(buzilgan))}")
print()
print("`html.parser` buzilgan HTML ni kechiradi — brauzer kabi.")
print("Shuning uchun yig'uvda XML parser (`xml`, `lxml-xml`) ishlatilmaydi:")
print("u qat'iy va birinchi xatoda to'xtaydi.")

jadval = []
for ustun in ["sarlavha", "narx_xom", "xona_xom", "maydon_xom", "tuman", "qavat_xom"]:
    yoq = int(xom_df[ustun].isna().sum())
    jadval.append({"ustun": ustun, "bo'sh": yoq,
                   "bo'sh %": f"{yoq / len(xom_df):.1%}",
                   "noyob qiymat": int(xom_df[ustun].nunique())})
show(pd.DataFrame(jadval))

print("Narx ustuni — nechta xil format?")
for n in xom_df["narx_xom"].dropna().unique()[:8]:
    print(f"  {n!r}")
print()
usd = xom_df["narx_xom"].str.contains("у.е.", na=False).sum()
som = xom_df["narx_xom"].str.contains("so'm", na=False).sum()
kel = xom_df["narx_xom"].str.contains("Kelishilgan", na=False).sum()
print(f"  у.е. ko'rinishida : {usd}")
print(f"  so'm ko'rinishida : {som}")
print(f"  'Kelishilgan'     : {kel}   <- raqam YO'Q, lekin qator bor")
print()
print("Uchta format uchta xil qayta ishlash talab qiladi. Bu — 37-bobning ishi.")

variantlar = [
    ("manba_id (sayt bergan id)", ["manba_id"]),
    ("sarlavha + tuman + maydon + narx", ["sarlavha", "tuman", "maydon_xom", "narx_xom"]),
    ("tuman + maydon + xona", ["tuman", "maydon_xom", "xona_xom"]),
]
natijalar = []
for nom, kalit in variantlar:
    qoldi = len(xom_df.drop_duplicates(subset=kalit))
    natijalar.append({"dublikat kaliti": nom, "noyob qoldi": qoldi,
                      "olib tashlanadi": len(xom_df) - qoldi})
show(pd.DataFrame(natijalar))
print(f"Jami yozuv: {len(xom_df)}")

takrorlangan = xom_df["maydon_xom"].value_counts()
ortiqcha = int((takrorlangan[takrorlangan > 1] - 1).sum())
print(f"Maydon qiymati bir martadan ko'p uchragan: {int((takrorlangan > 1).sum())} ta")
print(f"Haqiqiy ortiqcha yozuv soni             : {ortiqcha}")
print()
print("Maydon — uyning FIZIK xossasi. Ikki e'londa aynan bir xil maydon bo'lsa,")
print("bu deyarli har doim bitta uy ikki marta e'lon qilingani degani.")

import json
api = json.loads((FIX / "api.json").read_text(encoding="utf-8"))
print(f"API javobi kalitlari: {list(api.keys())}")
print(f"Jami yozuv: {api['jami']}, sahifa hajmi: {api['sahifa_hajmi']}")
print()
print("Birinchi yozuv:")
for k, v in api["natijalar"][0].items():
    print(f"  {k:<12} {v!r}  ({type(v).__name__})")
print()
api_df = pd.DataFrame(api["natijalar"])
print(f"DataFrame: {api_df.shape}")
print(f"Bo'sh qiymat: {int(api_df.isna().sum().sum())}")
print(f"Tiplar to'g'ri: {dict(api_df.dtypes.astype(str))}")

show(pd.DataFrame([
    {"Jihat": "Narx", "HTML scraping": "3 xil matn format", "API": "son, bitta birlik"},
    {"Jihat": "Bo'sh maydon", "HTML scraping": "bor", "API": "yo'q"},
    {"Jihat": "Dublikat", "HTML scraping": "bor", "API": "id bo'yicha toza"},
    {"Jihat": "Sayt dizayni o'zgarsa", "HTML scraping": "kod buziladi", "API": "ishlaydi (versiya bor)"},
    {"Jihat": "Shartlar", "HTML scraping": "noaniq", "API": "yozilgan"},
    {"Jihat": "Tezlik", "HTML scraping": "sekin (HTML katta)", "API": "tez (faqat ma'lumot)"},
]))
print()
print("Shuning uchun qoida: API bor bo'lsa, scraping yozishga vaqt sarflamaysiz.")

"""Sahifalangan API dan hamma yozuvni olish — chegarani hurmat qilib."""
import json
import time
from pathlib import Path


def hamma_sahifa(ol_funksiya, sahifa_hajmi=10, maks_sahifa=100, kechikish=1.0):
    """`ol_funksiya(ofset, limit)` -> dict. Hamma yozuvni yig'adi.

    maks_sahifa — himoya: API 'keyingi sahifa bor' deb cheksiz aytsa,
    kod abadiy aylanmasligi kerak.
    """
    hammasi, ofset = [], 0
    for _ in range(maks_sahifa):
        javob = ol_funksiya(ofset, sahifa_hajmi)
        bolak = javob.get("natijalar", [])
        if not bolak:
            break
        hammasi += bolak
        ofset += len(bolak)
        if ofset >= javob.get("jami", 0):
            break
        time.sleep(kechikish)
    return hammasi

from yiguv.api_mijoz import hamma_sahifa

sorovlar = {"soni": 0}
def mahalliy_api(ofset, limit):
    """Haqiqiy API ni taqlid qiladi — tarmoq yo'q, sahifalash bor."""
    sorovlar["soni"] += 1
    return {"jami": api["jami"], "natijalar": api["natijalar"][ofset:ofset + limit]}

olingan = hamma_sahifa(mahalliy_api, sahifa_hajmi=10, kechikish=0)
print(f"So'rov soni     : {sorovlar['soni']}")
print(f"Olingan yozuv   : {len(olingan)}")
print(f"API dagi jami   : {api['jami']}")
print(f"Hammasi olindi  : {len(olingan) == api['jami']}")

XOM = ISH / "xom"
XOM.mkdir(exist_ok=True)
yol = XOM / "elonlar_xom.csv"
xom_df.to_csv(yol, index=False)
print(f"Saqlandi: ish/xom/{yol.name}")
print(f"  {len(xom_df)} qator, {len(xom_df.columns)} ustun")
print(f"  hajmi: {yol.stat().st_size} bayt")
print()
print("Diqqat: bu fayl ATAYLAB iflos. Tozalash — 37-bobning vazifasi.")
print("Yig'uv va tozalash alohida qadamlar: yig'uv xomni oladi, tozalash qaror qabul qiladi.")

show(pd.DataFrame([
    {"Qadam": "0. Qoidalarni tekshir", "Natija": "robots.txt, ToS, shaxsiy ma'lumot qarori"},
    {"Qadam": "1. Manbani tanla", "Natija": "API > eksport > hamkorlik > scraping"},
    {"Qadam": "2. Xomni yig'ib saqla", "Natija": "kesh/ papkasi — bir marta yuklanadi"},
    {"Qadam": "3. Tahlil qil", "Natija": "xom/elonlar_xom.csv — tozalanmagan"},
    {"Qadam": "4. Dataset qur", "Natija": "37-bob: tozalash, dedup, split"},
]))

show(pd.DataFrame([
    {"Tushuncha": "Qoidalar koddan oldin", "Bitta jumla": "robots.txt, ToS, sekin so'rash, shaxsiyni yig'maslik"},
    {"Tushuncha": "Manba tartibi", "Bitta jumla": "API > eksport > hamkorlik so'rash > scraping"},
    {"Tushuncha": "select_one None qaytaradi", "Bitta jumla": "Har natija tekshiriladi, aks holda yig'uv to'xtaydi"},
    {"Tushuncha": "html.parser", "Bitta jumla": "Buzilgan HTML ni kechiradi, XML parser yo'q"},
    {"Tushuncha": "Kesh", "Bitta jumla": "Bir marta yuklanadi — xushmuomilalik va tezlik"},
    {"Tushuncha": "ID noyobligi aldaydi", "Bitta jumla": "O'lchandi: id boshqa, mazmun bir xil"},
    {"Tushuncha": "Shaxsiy ma'lumot", "Bitta jumla": "Yozilmagan ma'lumot o'g'irlanmaydi"},
    {"Tushuncha": "Xomni saqla", "Bitta jumla": "Qayta yig'ish qimmat, disk arzon"},
]))