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/
│   ├── weekly.py        ← hisobot matnini tuzish
│   └── anomaly.py       ← anomaliya mantiqiy
└── 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
from pathlib import Path

STATE_FILE = Path("var/scheduler_state.json")


def load_sent() -> set[str]:
    if not STATE_FILE.exists():
        return set()
    return set(json.loads(STATE_FILE.read_text()))


def mark_sent(key: str) -> None:
    sent = load_sent()
    sent.add(key)
    STATE_FILE.parent.mkdir(exist_ok=True)
    # oxirgi 200 kalit yetarli — fayl cheksiz o'smasin
    STATE_FILE.write_text(json.dumps(sorted(sent)[-200:], ensure_ascii=False))

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

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

# 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 (ishga tushirish)
async def main():
    # scheduler bot polling bilan YONMA-YON yashaydi
    asyncio.create_task(scheduler_loop(bot))
    await dp.start_polling(bot)

# 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_still_fires_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