AI tushunadi, formula hisoblaydi: LLM'ni narx hisobiga aralashtirmaslik

Erkin matn ──► LLM (STRUKTURA AJRATADI) ──► {"name": "...", "qty": 20, ...}
                                                   │
                                                   ▼
                            Deterministik tarif xizmati (NARXNI HISOBLAYDI)
                                                   │
                                                   ▼
                                          Bir xil kirish = bir xil narx

bot/
├── ai/
│   ├── __init__.py
│   ├── schemas.py       ← LLM chiqishi sxemasi (hozir shu yerdamiz)
│   └── extractor.py     ← LLM chaqiruvi
├── tariff/
│   ├── __init__.py
│   └── calculator.py    ← deterministik hisob
└── handlers/
    └── ai_calc.py       ← bot handler: ikkalasini bog'laydi

# bot/ai/schemas.py
from pydantic import BaseModel, Field


class CargoItem(BaseModel):
    """LLM'dan qaytishi SHART bo'lgan struktura — boshqa hech narsa."""

    name: str = Field(description="Tovar nomi, qisqa")
    quantity: int = Field(gt=0, description="Nechta birlik (quti, dona...)")
    unit_weight_kg: float | None = Field(
        default=None, ge=0, description="Bir birlik og'irligi, kg. Aytilmagan bo'lsa null"
    )
    total_volume_m3: float | None = Field(
        default=None, ge=0, description="Umumiy hajm, m³. Aytilmagan bo'lsa null"
    )


class ExtractionResult(BaseModel):
    items: list[CargoItem]
    # LLM topa olmagan narsani TAXMIN QILMASIN — ochiq aytsin:
    missing: list[str] = Field(
        default_factory=list,
        description="Hisob uchun yetishmayotgan ma'lumotlar ro'yxati (o'zbekcha)",
    )

uv add openai pydantic

# bot/ai/extractor.py
from functools import cache

from openai import AsyncOpenAI

from .schemas import ExtractionResult

SYSTEM = """Sen logistika botining ajratuvchisisan. Foydalanuvchi yuk tavsifini
o'zbek, rus yoki aralash tilda yozadi. Vazifang — FAQAT strukturani ajratish.
Qoidalar:
- hech narsani hisoblama, narx aytma;
- aytilmagan qiymatni taxmin qilma — null qoldir va missing'ga yoz;
- og'irlikni kg'da, hajmni m³'da yoz: tonna→kg, gramm→kg, litr→m³ (1000 litr = 1 m³),
  "yarim kub" → 0.5."""


class ExtractionRefused(Exception):
    """Model javob berishdan bosh tortdi — sxemali natija yo'q."""


@cache
def _client() -> AsyncOpenAI:
    # Mijoz birinchi chaqiruvda yaratiladi. OPENAI_API_KEY yo'q bo'lsa, xato
    # import paytida butun botni emas, faqat shu chaqiruvni yiqitadi — handler
    # uni ushlab, mijozni formaga yo'naltiradi.
    # SDK standart holatda javobni 600 soniya kutadi va 2 marta qayta uradi —
    # chatda odam javob kutyapti, shuning uchun kutishni qisqartiramiz
    return AsyncOpenAI(timeout=20, max_retries=1)


async def extract_cargo(text: str) -> ExtractionResult:
    # async mijoz: sinxron chaqiruv so'rov davomida butun botni to'xtatib qo'yardi
    response = await _client().chat.completions.parse(
        model="gpt-4o-mini",  # ajratish uchun kichik model yetarli va arzon
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": text},
        ],
        # parse() javobni Pydantic sxemaga majburlaydi: model sxemadan
        # tashqari JSON qaytara olmaydi
        response_format=ExtractionResult,
        temperature=0,  # ajratish ijod emas — barqarorlik kerak
    )
    message = response.choices[0].message
    if message.parsed is None:
        # model rad etsa, parsed bo'sh keladi, sababi esa refusal'da
        raise ExtractionRefused(message.refusal or "bo'sh javob")
    return message.parsed

# bot/tariff/calculator.py
from dataclasses import dataclass
from decimal import ROUND_HALF_UP, Decimal

from bot.ai.schemas import CargoItem

CENT = Decimal("0.01")


@dataclass(frozen=True)
class Tariff:
    """Zichlik oralig'iga bitta narx: [min_density, max_density) kg/m³."""

    min_density: Decimal
    max_density: Decimal
    price_per_kg: Decimal | None  # zich yuk uchun
    price_per_m3: Decimal | None  # hajmli yuk uchun


# Real tizimda bu ro'yxat bazadan/Excel'dan keladi (Humo'da menejerlar
# o'zi yangilaydi) — bu yerda soddalik uchun konstanta.
# Pul — Decimal: float'da 34.425 ikkilik ko'rinishda 34.4249999... bo'lib,
# sent noto'g'ri tomonga yuvarlanadi
TARIFFS = [
    Tariff(Decimal("0"), Decimal("100"), None, Decimal("180.00")),  # juda hajmli: kub bilan
    Tariff(Decimal("100"), Decimal("250"), Decimal("1.10"), None),  # o'rtacha: kilo bilan
    Tariff(Decimal("250"), Decimal("Infinity"), Decimal("0.85"), None),  # zich: arzonroq
]


class CalculationError(Exception):
    pass


def calculate(items: list[CargoItem]) -> dict:
    # Sof funksiya o'z shartlarini O'ZI himoya qiladi: LLM missing'ga yozishni
    # unutsa ham, og'irligi yoki hajmi yo'q tovar jimgina 0 deb hisoblanmaydi
    incomplete = [i.name for i in items if i.unit_weight_kg is None or i.total_volume_m3 is None]
    if incomplete:
        raise CalculationError("og'irligi yoki hajmi aytilmagan: " + ", ".join(incomplete))

    # float → Decimal str() orqali: 0.1 kabi sonning ikkilik xatosi olib kirilmasin
    total_kg = sum((Decimal(str(i.unit_weight_kg)) * i.quantity for i in items), Decimal(0))
    total_m3 = sum((Decimal(str(i.total_volume_m3)) for i in items), Decimal(0))
    if total_kg <= 0 or total_m3 <= 0:
        raise CalculationError("og'irlik va hajm musbat bo'lishi shart")

    density = total_kg / total_m3
    tariff = next(t for t in TARIFFS if t.min_density <= density < t.max_density)

    if tariff.price_per_kg is not None:
        price = (total_kg * tariff.price_per_kg).quantize(CENT, rounding=ROUND_HALF_UP)
        basis = f"{total_kg.normalize():f} kg × ${tariff.price_per_kg}"
    else:
        price = (total_m3 * tariff.price_per_m3).quantize(CENT, rounding=ROUND_HALF_UP)
        basis = f"{total_m3.normalize():f} m³ × ${tariff.price_per_m3}"

    return {
        "price_usd": price,
        "density": density.quantize(Decimal("0.1"), rounding=ROUND_HALF_UP),
        "basis": basis,
    }

# bot/handlers/ai_calc.py
import logging

from aiogram import F, Router, html, types

from bot.ai.extractor import extract_cargo
from bot.tariff.calculator import CalculationError, calculate

router = Router()
logger = logging.getLogger(__name__)


# buyruq bo'lmagan har qanday matn — yukning erkin tavsifi
@router.message(F.text, ~F.text.startswith("/"))
async def handle_ai_calc(message: types.Message):
    try:
        extraction = await extract_cargo(message.text)
    except Exception:
        # AI ishlamasa (kalit yo'q, timeout, kvota, rad etish) — mijozni klassik
        # formaga yo'naltiramiz. Bot AI'siz ham TO'LIQ ishlashi shart
        logger.exception("AI ajratish ishlamadi")
        await message.answer(
            "Hozir avtomatik tahlil ishlamayapti. /calc bilan forma orqali hisoblang."
        )
        return

    if extraction.missing:
        # taxmin qilmaymiz — so'raymiz. AI'ning "bilmadim"i — xato emas, xususiyat
        missing = "\n".join(f"— {m}" for m in extraction.missing)
        await message.answer(f"Hisob uchun quyidagilar yetishmayapti:\n{missing}")
        return

    try:
        result = calculate(extraction.items)
    except CalculationError as exc:
        await message.answer(f"Hisoblab bo'lmadi: {exc}")
        return

    # tovar nomi foydalanuvchi matnidan chiqqan — HTML ichiga ekranlab qo'yamiz
    names = html.quote(", ".join(i.name for i in extraction.items))
    await message.answer(
        f"📦 {names}\n"
        f"Zichlik: {result['density']} kg/m³\n"
        f"Hisob: {result['basis']}\n"
        f"<b>Narx: ${result['price_usd']}</b>",
        parse_mode="HTML",
    )

# tests/test_calculator.py
from decimal import Decimal

import pytest

from bot.ai.schemas import CargoItem
from bot.tariff.calculator import CalculationError, calculate


def item(qty=20, kg=3.0, m3=0.5, name="aksessuar"):
    return CargoItem(name=name, quantity=qty, unit_weight_kg=kg, total_volume_m3=m3)


def test_medium_density_priced_per_kg():
    # 60 kg / 0.5 m³ = 120 kg/m³ → o'rta tarif, kilo bilan
    result = calculate([item()])
    assert result == {
        "price_usd": Decimal("66.00"),
        "density": Decimal("120.0"),
        "basis": "60 kg × $1.10",
    }


def test_bulky_cargo_priced_per_m3():
    # 10 kg / 0.5 m³ = 20 kg/m³ → hajmli tarif, kub bilan
    result = calculate([item(qty=10, kg=1.0)])
    assert result["basis"] == "0.5 m³ × $180.00"
    assert result["price_usd"] == Decimal("90.00")


def test_half_cent_rounds_up():
    # 40.5 kg × $0.85 = 34.425 → 34.43 (float bilan 34.42 chiqardi)
    result = calculate([item(qty=1, kg=40.5, m3=0.1)])
    assert result["price_usd"] == Decimal("34.43")


def test_item_without_weight_is_not_priced_as_zero():
    items = [item(), item(qty=100, kg=None, name="kabel")]
    with pytest.raises(CalculationError, match="kabel"):
        calculate(items)


def test_zero_weight_rejected():
    with pytest.raises(CalculationError):
        calculate([item(kg=0.0, m3=0.0)])

uv add --dev pytest
uv run python -m pytest tests -q