Add

advice.py

@@ -0,0 +1,176 @@
+import os
+import re
+import pandas as pd
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from common import read_json_stdin, write_json_stdout, current_month_snapshot, clean_ru
+
+ALLOWED_MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
+
+os.environ.setdefault("OMP_NUM_THREADS", "1")
+os.environ.setdefault("MKL_NUM_THREADS", "1")
+try:
+    torch.set_num_threads(1)
+except Exception:
+    pass
+
+_DEVICE = torch.device("cpu")
+_tokenizer = None
+_model = None
+_loaded = False
+
+
+def _load():
+    global _tokenizer, _model, _loaded
+    if _loaded and _tokenizer is not None and _model is not None:
+        return _tokenizer, _model
+
+    _tokenizer = AutoTokenizer.from_pretrained(
+        ALLOWED_MODEL_ID,
+        trust_remote_code=True,
+    )
+    _model = AutoModelForCausalLM.from_pretrained(
+        ALLOWED_MODEL_ID,
+        torch_dtype=torch.float32,
+        low_cpu_mem_usage=True,
+        trust_remote_code=True,
+    ).to(_DEVICE).eval()
+
+    if _tokenizer.pad_token_id is None:
+        _tokenizer.pad_token_id = _tokenizer.eos_token_id
+
+    _loaded = True
+    return _tokenizer, _model
+
+
+def _gen(messages, tok, mdl, max_new_tokens=200, det=True):
+    txt = tok.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+    inputs = tok(
+        txt,
+        return_tensors="pt",
+        padding=True,
+        truncation=True,
+        max_length=1400,
+    ).to(_DEVICE)
+
+    with torch.no_grad():
+        common = dict(
+            max_new_tokens=max_new_tokens,
+            repetition_penalty=1.08 if det else 1.12,
+            no_repeat_ngram_size=5 if det else 6,
+            eos_token_id=tok.eos_token_id,
+            pad_token_id=tok.pad_token_id,
+        )
+        if det:
+            out = mdl.generate(
+                **inputs,
+                do_sample=False,
+                num_beams=4,
+                **common,
+            )
+        else:
+            out = mdl.generate(
+                **inputs,
+                do_sample=True,
+                temperature=0.8,
+                top_p=0.9,
+                top_k=50,
+                **common,
+            )
+    return tok.decode(out[0], skip_special_tokens=True)
+
+
+_BULLET_KILL = re.compile(
+    r"(?i)(учитывай данные|данные пользователя|месяц:|доход:|расход:|нетто:|топ стат|вопрос:|assistant)"
+)
+_ONLY_PUNCT = re.compile(r"^[-•\s\.\,\;\:\!\?]+$")
+
+
+def _to_bullets(text: str) -> str:
+    if not text:
+        return ""
+    m = re.search(r"(\n\s*[-*]\s+|\n\s*\d+[\).\s]+|•)", "\n" + text)
+    if m:
+        text = text[m.start() :]
+
+    text = re.sub(r"^\s*[*•]\s+", "- ", text, flags=re.M)
+    text = re.sub(r"^\s*\d+[\).\s]+", "- ", text, flags=re.M)
+
+    uniq, seen = [], set()
+    for ln in text.split("\n"):
+        s = ln.strip()
+        if not s or not s.startswith("- "):
+            continue
+        if _BULLET_KILL.search(s) or _ONLY_PUNCT.match(s):
+            continue
+        s = re.sub(r"\s{2,}", " ", s)
+        s = re.sub(r"\.\s*\.+$", ".", s)
+        key = s.lower()
+        if key in seen:
+            continue
+        seen.add(key)
+        uniq.append(s)
+        if len(uniq) >= 7:
+            break
+
+    return "\n".join(s.replace("- ", "• ", 1) for s in uniq)
+
+
+def main():
+    req = read_json_stdin()
+
+    tx = req.get("transactions") or []
+    question = (req.get("question") or "").strip()
+    
+    df = pd.DataFrame(tx) if tx else None
+    snap = current_month_snapshot(df) if df is not None and not df.empty else {}
+
+    if snap:
+        ctx = [
+            f"Месяц: {snap['month']}",
+            f"Доход: {snap['income_total']:.0f}",
+            f"Расход: {abs(snap['expense_total']):.0f}",
+            f"Нетто: {snap['net']:.0f}",
+        ]
+        if snap.get("top_expense_categories"):
+            ctx.append("Топ статей расходов:")
+            for cat, val in snap["top_expense_categories"]:
+                ctx.append(f"- {cat}: {abs(val):.0f}")
+        context = "\n".join(ctx)
+    else:
+        context = "Данных за текущий месяц нет."
+
+    system_msg = (
+        "Ты финансовый помощник. Отвечай по-русски. "
+        "Верни ТОЛЬКО список из 5–7 конкретных шагов экономии с цифрами (лимиты, проценты, частота). "
+        "Каждая строка должна начинаться с символов \"- \". Никаких вступлений."
+    )
+    messages = [
+        {"role": "system", "content": system_msg},
+        {
+            "role": "user",
+            "content": (
+                f"Мои данные за текущий месяц:\n{context}\n\nВопрос: {question}\n"
+                "Начни ответ сразу со строки, которая начинается с \"- \". Верни только список."
+            ),
+        },
+    ]
+
+    tok, mdl = _load()
+    raw = _gen(messages, tok, mdl, det=True)
+    text = _to_bullets(clean_ru(raw))
+
+    if text.count("\n") + 1 < 3:
+        raw2 = _gen(messages, tok, mdl, det=False)
+        text2 = _to_bullets(clean_ru(raw2))
+        if text2:
+            text = text2
+
+    write_json_stdout({"advice": text})
+
+
+if __name__ == "__main__":
+    main()

app.py

@@ -0,0 +1,179 @@
+# app.py
+import os
+import tempfile
+from decimal import Decimal
+from typing import List, Optional
+
+import pandas as pd
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from pydantic import BaseModel
+
+from common import prepare_components_series, fit_and_forecast, current_month_snapshot
+from advice import _load as advice_load, _gen as advice_gen, _to_bullets, clean_ru
+from receipt_total_api import extract_total
+
+app = FastAPI()
+
+# ---------- Pydantic-модели под Go-структуры ----------
+
+
+class Transaction(BaseModel):
+    date: str
+    amount: Decimal
+    type: str
+    category: Optional[str] = None
+    description: Optional[str] = None
+
+
+class ForecastRequest(BaseModel):
+    granularity: str
+    steps: int
+    model: Optional[str] = None
+    transactions: List[Transaction]
+
+
+class ForecastResponse(BaseModel):
+    period_end: List[str]
+    income_forecast: List[float]
+    expense_forecast: List[float]
+
+
+class AdviceRequest(BaseModel):
+    question: Optional[str] = None
+    transactions: List[Transaction] = []
+
+
+class AdviceResponse(BaseModel):
+    advice: str
+
+
+class ReceiptResponse(BaseModel):
+    total: Optional[float]
+
+
+# ---------- Стартуем и заранее грузим модели ----------
+
+advice_tokenizer = None
+advice_model = None
+
+
+@app.on_event("startup")
+def load_models():
+    """
+    Загружаем Qwen один раз при старте сервиса.
+    Donut для чеков грузится в receipt_total_api при первом импорте.
+    """
+    global advice_tokenizer, advice_model
+    advice_tokenizer, advice_model = advice_load()
+
+
+# ---------- Эндпоинты ----------
+
+
+@app.post("/forecast", response_model=ForecastResponse)
+def forecast(req: ForecastRequest):
+    if not req.transactions:
+        raise HTTPException(status_code=400, detail="transactions is empty")
+
+    df = pd.DataFrame([t.dict() for t in req.transactions])
+
+    gran = (req.granularity or "month").lower()
+    freq = "A-DEC" if gran.startswith("y") else "M"
+    steps = int(req.steps or 1)
+    method = (req.model or "auto").lower()
+
+    inc, exp, _ = prepare_components_series(df, freq=freq)
+    inc_fc = fit_and_forecast(inc, steps, freq, method=method)
+    exp_fc = fit_and_forecast(exp, steps, freq, method=method)
+
+    return ForecastResponse(
+        period_end=[
+            d.strftime("%Y-%m-%d") for d in inc_fc.index.to_pydatetime().tolist()
+        ],
+        income_forecast=[float(x) for x in inc_fc.values.tolist()],
+        expense_forecast=[float(x) for x in exp_fc.values.tolist()],
+    )
+
+
+@app.post("/advice", response_model=AdviceResponse)
+def advice(req: AdviceRequest):
+    tx = [t.dict() for t in req.transactions] if req.transactions else []
+    df = pd.DataFrame(tx) if tx else None
+    snap = current_month_snapshot(df) if df is not None and not df.empty else {}
+
+    if snap:
+        ctx = [
+            f"Месяц: {snap['month']}",
+            f"Доход: {snap['income_total']:.0f}",
+            f"Расход: {abs(snap['expense_total']):.0f}",
+            f"Нетто: {snap['net']:.0f}",
+        ]
+        if snap.get("top_expense_categories"):
+            ctx.append("Топ статей расходов:")
+            for cat, val in snap["top_expense_categories"]:
+                ctx.append(f"- {cat}: {abs(val):.0f}")
+        context = "\n".join(ctx)
+    else:
+        context = "Данных за текущий месяц нет."
+
+    question = (req.question or "").strip()
+
+    system_msg = (
+        "Ты финансовый помощник. Отвечай по-русски. "
+        "Верни ТОЛЬКО список из 5–7 конкретных шагов экономии с цифрами (лимиты, проценты, частота). "
+        "Каждая строка должна начинаться с символов \"- \". Никаких вступлений."
+    )
+    messages = [
+        {"role": "system", "content": system_msg},
+        {
+            "role": "user",
+            "content": (
+                f"Мои данные за текущий месяц:\n{context}\n\nВопрос: {question}\n"
+                'Начни ответ сразу со строки, которая начинается с "- ". Верни только список.'
+            ),
+        },
+    ]
+
+    raw = advice_gen(messages, advice_tokenizer, advice_model, det=True)
+    text = _to_bullets(clean_ru(raw))
+
+    # fallback на стохастический прогон, если мало пунктов
+    from advice import _gen as advice_gen2, _to_bullets as to_bullets2
+
+    if text.count("\n") + 1 < 3:
+        raw2 = advice_gen2(messages, advice_tokenizer, advice_model, det=False)
+        text2 = to_bullets2(clean_ru(raw2))
+        if text2:
+            text = text2
+
+    return AdviceResponse(advice=text)
+
+
+@app.post("/receipt-total-file", response_model=ReceiptResponse)
+async def receipt_total_file(file: UploadFile = File(...)):
+    """
+    Получает файл чека (multipart/form-data, field "file"),
+    сохраняет во временный файл, вызывает extract_total и возвращает сумму.
+    """
+    # сохраняем во временный файл
+    suffix = os.path.splitext(file.filename or "")[1] or ".jpg"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+        contents = await file.read()
+        tmp.write(contents)
+        tmp_path = tmp.name
+
+    try:
+        total = extract_total(tmp_path)
+        return ReceiptResponse(total=total)
+    finally:
+        try:
+            os.remove(tmp_path)
+        except OSError:
+            pass
+
+
+# Для локального запуска, на HF Space это не используется
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, workers=1)

common.py

@@ -0,0 +1,173 @@
+import re
+import json
+import numpy as np
+import pandas as pd
+from typing import Optional, Tuple
+from statsmodels.tsa.holtwinters import ExponentialSmoothing, Holt
+
+try:
+    from prophet import Prophet
+    _HAS_PROPHET = True
+except Exception:
+    _HAS_PROPHET = False
+
+_KEEP = re.compile(r"[^А-Яа-яЁё0-9 ,.!?:;()«»\"'–—\-•\n]")
+
+def clean_ru(text: str) -> str:
+    text = _KEEP.sub(" ", text or "")
+    return re.sub(r"\s+", " ", text).strip()
+
+def normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
+    work = df.copy()
+    for col in list(work.columns):
+        lc = col.lower()
+        if lc in ("date", "дата"):
+            work.rename(columns={col: "date"}, inplace=True)
+        elif lc in ("amount", "сумма"):
+            work.rename(columns={col: "amount"}, inplace=True)
+        elif lc in ("category", "категория"):
+            work.rename(columns={col: "category"}, inplace=True)
+        elif lc in ("type", "тип"):
+            work.rename(columns={col: "type"}, inplace=True)
+    required = {"date", "amount", "type"}
+    missing = required - set(map(str, work.columns))
+    if missing:
+        raise ValueError(f"Отсутствуют колонки: {', '.join(sorted(missing))}")
+    work["date"] = pd.to_datetime(work["date"], errors="coerce")
+    work = work.dropna(subset=["date"])
+    work["amount"] = pd.to_numeric(work["amount"], errors="coerce").fillna(0.0)
+    if "category" not in work.columns:
+        work["category"] = "Без категории"
+    return work
+
+def is_expense(t: str) -> bool:
+    t = str(t).strip().lower()
+    return t in {"expense", "расход", "расходы", "-", "e", "exp"}
+
+def is_income(t: str) -> bool:
+    t = str(t).strip().lower()
+    return t in {"income", "доход", "+", "i", "inc"}
+
+def prepare_components_series(df: pd.DataFrame, freq: str="M") -> Tuple[pd.Series, pd.Series, pd.Series]:
+    if df is None or df.empty:
+        raise ValueError("Пустая таблица транзакций.")
+    work = normalize_columns(df)
+    work["is_expense"] = work["type"].apply(is_expense)
+    work["is_income"] = work["type"].apply(is_income)
+
+    inc = work.loc[work["is_income"]].set_index("date")["amount"].resample(freq).sum().sort_index()
+    exp = work.loc[work["is_expense"]].set_index("date")["amount"].abs().mul(-1).resample(freq).sum().sort_index()
+
+    if not inc.empty or not exp.empty:
+        start = min([x.index.min() for x in [inc, exp] if not x.empty])
+        end   = max([x.index.max() for x in [inc, exp] if not x.empty])
+        full_idx = pd.date_range(start, end, freq=freq)
+        inc = inc.reindex(full_idx, fill_value=0.0)
+        exp = exp.reindex(full_idx, fill_value=0.0)
+    net = inc + exp
+    inc.index.name = exp.index.name = net.index.name = "period_end"
+    return inc, exp, net
+
+def fit_and_forecast(history: pd.Series, steps: int, freq: str, method: str = "auto") -> pd.Series:
+    if len(history) < 3:
+        last = float(history.iloc[-1]) if len(history) else 0.0
+        start = (history.index[-1] if len(history) else pd.Timestamp.today().normalize()) + \
+                pd.tseries.frequencies.to_offset(freq)
+        idx = pd.date_range(start, periods=steps, freq=freq)
+        return pd.Series([last] * steps, index=idx, name="forecast")
+
+    use_prophet = False
+    if method == "prophet":
+        use_prophet = True
+    elif method == "auto":
+        if freq.startswith("A"):                 
+            use_prophet = _HAS_PROPHET and (len(history) >= 5)
+        else:                                       
+            use_prophet = _HAS_PROPHET and (len(history) >= 18)
+
+    if use_prophet:
+        try:
+            pfreq = "Y" if freq.startswith("A") else "M"
+            dfp = history.reset_index()
+            dfp.columns = ["ds", "y"]
+
+            m = Prophet(
+                yearly_seasonality=(pfreq == "M"),
+                weekly_seasonality=False,
+                daily_seasonality=False,
+                seasonality_mode="additive",
+            )
+            m.fit(dfp)
+            future = m.make_future_dataframe(periods=steps, freq=pfreq)
+            fcst = m.predict(future).tail(steps)
+            yhat = pd.Series(fcst["yhat"].values, index=pd.DatetimeIndex(fcst["ds"]), name="forecast")
+
+            if pfreq == "M":
+                yhat.index = yhat.index.to_period("M").to_timestamp(how="end")
+            else:
+                yhat.index = yhat.index.to_period("Y").to_timestamp(how="end")
+
+            if yhat.index.freq is None:
+                yhat.index = pd.date_range(yhat.index[0], periods=len(yhat), freq=("A-DEC" if pfreq == "Y" else "M"))
+            return yhat
+        except Exception:
+            pass
+
+    try:
+        if freq.startswith("A"):
+            model = Holt(history, initialization_method="estimated")
+        else:
+            if len(history) >= 24:
+                model = ExponentialSmoothing(
+                    history, trend="add", seasonal="add", seasonal_periods=12,
+                    initialization_method="estimated"
+                )
+            else:
+                model = Holt(history, initialization_method="estimated")
+        fit = model.fit(optimized=True)
+        fc = fit.forecast(steps)
+        if not isinstance(fc.index, pd.DatetimeIndex) or len(fc.index) != steps:
+            start = history.index[-1] + pd.tseries.frequencies.to_offset(freq)
+            idx = pd.date_range(start, periods=steps, freq=freq)
+            fc = pd.Series(np.asarray(fc), index=idx, name="forecast")
+        return fc
+    except Exception:
+        tail = min(6, len(history))
+        baseline = float(history.tail(tail).mean()) if tail else 0.0
+        start = history.index[-1] + pd.tseries.frequencies.to_offset(freq)
+        idx = pd.date_range(start, periods=steps, freq=freq)
+        return pd.Series([baseline] * steps, index=idx, name="forecast")
+
+def current_month_snapshot(df: pd.DataFrame) -> dict:
+    if df is None or df.empty:
+        return {}
+    w = normalize_columns(df)
+    w["is_income"] = w["type"].apply(is_income)
+    w["is_expense"] = w["type"].apply(is_expense)
+    lastp = w["date"].dt.to_period("M").max()
+    cur = w[w["date"].dt.to_period("M") == lastp].copy()
+    if cur.empty:
+        return {}
+    income_total  = float(cur.loc[cur["is_income"], "amount"].sum())
+    expense_total = -float(cur.loc[cur["is_expense"], "amount"].abs().sum())
+    net = income_total + expense_total
+    exp_df = cur.loc[cur["is_expense"], ["category","amount"]].copy()
+    exp_df["amount"] = -exp_df["amount"].abs()
+    top = exp_df.groupby("category")["amount"].sum().sort_values().head(5)
+    return {
+        "month": str(lastp),
+        "income_total": income_total,
+        "expense_total": expense_total,
+        "net": net,
+        "top_expense_categories": [(str(k), float(v)) for k,v in top.items()]
+    }
+
+def read_json_stdin() -> dict:
+    import sys
+    raw = sys.stdin.read()
+    return json.loads(raw or "{}")
+
+def write_json_stdout(obj) -> None:
+    import sys
+    sys.stdout.write(json.dumps(obj, ensure_ascii=False))
+    sys.stdout.flush()

receipt_total_api.py

@@ -0,0 +1,70 @@
+import sys
+import os
+import json
+import re
+import torch
+import numpy as np
+from PIL import Image
+from transformers import DonutProcessor, VisionEncoderDecoderModel
+
+#os.environ["TRANSFORMERS_CACHE"] = "/tmp"
+#os.environ["HF_HOME"] = "/tmp"
+
+MODEL_ID = "naver-clova-ix/donut-base-finetuned-cord-v2"
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+processor = DonutProcessor.from_pretrained(MODEL_ID)
+model = VisionEncoderDecoderModel.from_pretrained(MODEL_ID).to(device)
+
+def pick_total_from_text(text: str):
+    if not text:
+        return None
+    text = text.replace("\xa0", " ")
+    def _to_float(s):
+        s = s.replace(" ", "").replace(",", ".")
+        try: return float(s)
+        except: return None
+    eq_matches = re.findall(r"=\s*(-?\d{1,3}(?:[ .,\u00A0]?\d{3})*(?:[.,]\d{2}))", text)
+    for m in reversed(eq_matches):
+        v = _to_float(m)
+        if v and v > 0: return v
+    matches = re.findall(r"(-?\d{1,3}(?:[ .,\u00A0]?\d{3})*(?:[.,]\d{2}))", text)
+    best = None
+    for m in matches:
+        v = _to_float(m)
+        if v and 0 < v < 1e6:
+            best = v
+    return best
+
+def extract_total(image_path: str):
+    image = Image.open(image_path).convert("RGB")
+    task_prompt = "<s_cord-v2>"
+    pixel_values = processor(image, return_tensors="pt").pixel_values.to(device)
+    decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt").input_ids.to(device)
+    outputs = model.generate(
+        pixel_values,
+        decoder_input_ids=decoder_input_ids,
+        max_length=model.config.decoder.max_position_embeddings,
+        early_stopping=True,
+        pad_token_id=processor.tokenizer.pad_token_id,
+        eos_token_id=processor.tokenizer.eos_token_id,
+        use_cache=True,
+        num_beams=1,
+    )
+    seq = processor.batch_decode(outputs, skip_special_tokens=True)[0]
+    seq = seq.replace(task_prompt, "").replace("<s>", "").replace("</s>", "").strip()
+    try:
+        data = json.loads(seq)
+        for k in ["total", "total_price", "grand_total"]:
+            if k in data:
+                return float(str(data[k]).replace(",", "."))
+    except Exception:
+        pass
+    return pick_total_from_text(seq)
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: receipt_total_api.py path/to/receipt.jpg", file=sys.stderr)
+        sys.exit(1)
+    total = extract_total(sys.argv[1])
+    print(total if total is not None else "null")

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn[standard]
+pydantic
+pandas
+numpy
+torch
+transformers
+statsmodels
+pillow
+prophet