Botda rejalashtirilgan vazifalar: haftalik hisobot va anomaliya-alerting

bot/
├── scheduler/
│   ├── __init__.py
│   ├── periods.py       ← davr hisob-kitobi (sof funksiyalar — testlanadi)
│   ├── state.py         ← yuborilgan kalitlar fayli
│   └── runner.py        ← asyncio loop
├── reports/
│   ├── notify.py        ← adminlarga yuborish
│   ├── weekly.py        ← haftalik va oylik hisobot
│   └── anomaly.py       ← anomaliya mantiqiy
├── api/
│   └── stats_api.py     ← ko'rsatkichlar manbai (kompaniya API'si)
└── app.py

# bot/scheduler/periods.py
from datetime import datetime, timedelta, timezone

# Toshkent: UTC+5, DST yo'q — shuning uchun oddiy timedelta bilan xavfsiz
TZ = timezone(timedelta(hours=5))

WEEKLY_HOUR = 9  # dushanba 09:00
MONTHLY_DAY = 1  # oyning 1-kuni
ANOMALY_HOUR = 20  # har kuni 20:00 da kunlik tekshiruv


def week_key(now: datetime) -> str:
    """O'tgan TO'LIQ hafta kaliti: '2026-W33'."""
    last_sunday = now - timedelta(days=now.isoweekday())
    year, week, _ = last_sunday.isocalendar()
    return f"{year}-W{week:02d}"


def month_key(now: datetime) -> str:
    """O'tgan oy kaliti: '2026-07'."""
    first_of_month = now.replace(day=1)
    prev = first_of_month - timedelta(days=1)
    return f"{prev.year}-{prev.month:02d}"


def due_task(now: datetime, sent: set[str]) -> tuple[str, str] | None:
    """Navbatdagi BITTA vazifa: (tur, davr_kaliti) yoki None.

    Bitta chaqiruvda bitta vazifa — ikkitasi to'planib qolgan bo'lsa
    (masalan bot bir hafta o'chiq turdi), navbatma-navbat yuboriladi,
    adminlar oqimi bosilmaydi.
    """
    if now.isoweekday() == 1 and now.hour >= WEEKLY_HOUR:
        key = f"weekly:{week_key(now)}"
        if key not in sent:
            return ("weekly", key)
    if now.day == MONTHLY_DAY and now.hour >= WEEKLY_HOUR:
        key = f"monthly:{month_key(now)}"
        if key not in sent:
            return ("monthly", key)
    if now.hour >= ANOMALY_HOUR:
        key = f"anomaly:{now.date().isoformat()}"
        if key not in sent:
            return ("anomaly", key)
    return None

# bot/scheduler/state.py
import json
import logging
import os
from pathlib import Path

log = logging.getLogger(__name__)

STATE_FILE = Path("var/scheduler_state.json")
KEEP_LAST = 200  # fayl cheksiz o'smasin


def _load_keys() -> list[str]:
    if not STATE_FILE.exists():
        return []
    try:
        return json.loads(STATE_FILE.read_text())
    except json.JSONDecodeError:
        # Buzilgan fayl scheduler'ni butunlay to'xtatib qo'ymasin: ogohlantirib,
        # bo'sh ro'yxatdan boshlaymiz. Eng yomon holatda joriy davr hisoboti
        # bir marta qayta ketadi — hech qachon ketmaganidan yaxshi
        log.warning("scheduler holat fayli buzilgan, qaytadan boshlanadi")
        return []


def load_sent() -> set[str]:
    return set(_load_keys())


def mark_sent(key: str) -> None:
    keys = _load_keys()
    if key not in keys:
        keys.append(key)
    STATE_FILE.parent.mkdir(exist_ok=True)
    tmp = STATE_FILE.with_suffix(".tmp")
    # oxirgi 200 kalit — QO'SHILGAN tartibda. sorted() bilan kesilsa, "anomaly:"
    # alifboda "weekly:" dan oldin turgani uchun yangi kalitlar o'chib ketardi
    tmp.write_text(json.dumps(keys[-KEEP_LAST:], ensure_ascii=False))
    # atomar almashtirish: yozish o'rtasida tok o'chsa ham eski fayl butun qoladi
    os.replace(tmp, STATE_FILE)

# bot/reports/anomaly.py
from dataclasses import dataclass

from aiogram import Bot

from bot.api import stats_api
from bot.reports.notify import notify_admins

THRESHOLD = 0.5  # ±50% dan katta og'ish — e'tiborga loyiq


@dataclass(frozen=True)
class Anomaly:
    metric: str
    today: float
    baseline: float

    @property
    def change_pct(self) -> int:
        return round((self.today - self.baseline) / self.baseline * 100)


def detect(metrics: dict[str, float], baselines: dict[str, float]) -> list[Anomaly]:
    """metrics: bugungi qiymatlar; baselines: o'tgan davr o'rtachasi."""
    found = []
    for name, today in metrics.items():
        base = baselines.get(name)
        if not base:  # tarix yo'q — taqqoslab bo'lmaydi
            continue
        if abs(today - base) / base > THRESHOLD:
            found.append(Anomaly(name, today, base))
    return found


async def run_daily_check(bot: Bot) -> None:
    metrics, baselines = await stats_api.today_and_baseline()
    found = detect(metrics, baselines)
    if not found:
        return  # bot jim = hammasi joyida
    lines = [
        f"— {a.metric}: {a.today:g} (odatda {a.baseline:g}, {a.change_pct:+d}%)" for a in found
    ]
    await notify_admins(bot, "⚠️ Bugungi anomaliyalar:\n" + "\n".join(lines))

# bot/api/stats_api.py — interfeys (ichi kompaniya API'siga so'rov yuboradi)
async def weekly_summary() -> str:
    """O'tgan to'liq haftaning tayyor hisobot matni."""


async def monthly_summary() -> str:
    """O'tgan oyning tayyor hisobot matni."""


async def today_and_baseline() -> tuple[dict[str, float], dict[str, float]]:
    """Bugungi ko'rsatkichlar va o'tgan ikki haftaning shu kunlaridagi o'rtachasi."""

# bot/reports/weekly.py
from aiogram import Bot

from bot.api import stats_api
from bot.reports.notify import notify_admins


async def send_weekly_report(bot: Bot) -> None:
    await notify_admins(bot, await stats_api.weekly_summary())


async def send_monthly_report(bot: Bot) -> None:
    await notify_admins(bot, await stats_api.monthly_summary())

# bot/reports/notify.py
import logging
import os

from aiogram import Bot
from aiogram.exceptions import TelegramAPIError

log = logging.getLogger(__name__)

# .env: ADMIN_IDS=111111111,222222222
ADMIN_IDS = [int(x) for x in os.environ.get("ADMIN_IDS", "").split(",") if x.strip()]


async def notify_admins(bot: Bot, text: str) -> None:
    delivered = 0
    for admin_id in ADMIN_IDS:
        try:
            await bot.send_message(admin_id, text)
            delivered += 1
        except TelegramAPIError:
            # bitta admin botni bloklagan bo'lsa ham qolganlar xabarni olsin
            log.exception("admin %s ga yuborilmadi", admin_id)
    if delivered == 0:
        # hech kimga yetmadi (masalan, tarmoq yo'q) — vazifa muvaffaqiyatsiz:
        # runner kalitni yozmaydi va keyingi daqiqada qayta urinadi
        raise RuntimeError("xabar hech bir adminga yetib bormadi")

# bot/scheduler/runner.py
import asyncio
import logging
from datetime import datetime

from bot.reports import anomaly, weekly
from bot.scheduler.periods import TZ, due_task
from bot.scheduler.state import load_sent, mark_sent

log = logging.getLogger(__name__)

CHECK_EVERY = 60  # soniya

TASKS = {
    "weekly": weekly.send_weekly_report,
    "monthly": weekly.send_monthly_report,
    "anomaly": anomaly.run_daily_check,
}


async def scheduler_loop(bot):
    while True:
        try:
            now = datetime.now(TZ)
            task = due_task(now, load_sent())
            if task is not None:
                kind, key = task
                await TASKS[kind](bot)  # vazifaning o'zi
                mark_sent(key)  # MUVAFFAQIYATDAN KEYIN belgilanadi
                log.info("scheduler: %s yuborildi", key)
        except Exception:
            # bitta xato loop'ni o'ldirmasin: log yozamiz, keyingi aylanishda
            # qayta urinamiz (kalit belgilanmagan — vazifa yo'qolmaydi)
            log.exception("scheduler xatosi")
        await asyncio.sleep(CHECK_EVERY)

# bot/app.py
async def main() -> None:
    bot = Bot(os.environ["BOT_TOKEN"])
    # scheduler bot polling bilan YONMA-YON yashaydi. Havolani o'zgaruvchida
    # saqlaymiz: event loop task'larga faqat zaif havola tutadi, hech kim
    # ushlamagan task ish o'rtasida yig'ishtirib yuborilishi mumkin
    scheduler = asyncio.create_task(scheduler_loop(bot))
    try:
        await dp.start_polling(bot)
    finally:
        scheduler.cancel()

# tests/test_periods.py
from datetime import datetime

from bot.scheduler.periods import TZ, due_task


def dt(day, hour):
    return datetime(2026, 8, day, hour, 0, tzinfo=TZ)  # 2026-08-17 — dushanba


def test_weekly_fires_monday_after_nine():
    assert due_task(dt(17, 9), set()) == ("weekly", "weekly:2026-W33")


def test_weekly_not_resent_same_week():
    sent = {"weekly:2026-W33"}
    # dushanba kuni hisobot ketgan; endi navbat kunlik tekshiruvda (20:00 dan keyin)
    assert due_task(dt(17, 21), sent) == ("anomaly", "anomaly:2026-08-17")


def test_quiet_before_hours():
    assert due_task(dt(18, 8), {"weekly:2026-W33"}) is None


def test_missed_monday_is_skipped_on_tuesday():
    # bot dushanba butun kun o'chiq edi — seshanba ertalab baribir hafta kaliti yo'q...
    # lekin due_task faqat dushanba tekshiradi: bu qat'iy qaror — hafta hisobot
    # 24 soatdan ortiq kechiksa, keyingi haftani kutgan ma'qul (eskirgan tahlil
    # foydali emas). O'zingizga moslang: shartga `<= 2` kun qo'shsangiz ham bo'ladi
    assert due_task(dt(18, 9), set()) is None

# tests/test_state.py
import bot.scheduler.state as state


def test_newest_keys_survive_trimming(tmp_path, monkeypatch):
    monkeypatch.setattr(state, "STATE_FILE", tmp_path / "state.json")
    monkeypatch.setattr(state, "KEEP_LAST", 3)
    for key in ["weekly:2026-W30", "weekly:2026-W31", "weekly:2026-W32", "anomaly:2026-08-17"]:
        state.mark_sent(key)
    # alifbo bo'yicha "anomaly:" birinchi turadi — lekin eng yangi kalit saqlanishi shart
    assert state.load_sent() == {"weekly:2026-W31", "weekly:2026-W32", "anomaly:2026-08-17"}


def test_corrupted_file_does_not_stop_scheduler(tmp_path, monkeypatch):
    broken = tmp_path / "state.json"
    broken.write_text('["weekly:2026-W3')
    monkeypatch.setattr(state, "STATE_FILE", broken)
    assert state.load_sent() == set()

uv run python -m pytest tests -q