135 lines
5.1 KiB
Python
135 lines
5.1 KiB
Python
from datetime import date
|
|
from decimal import Decimal
|
|
|
|
import pandas as pd
|
|
from sqlalchemy import Select, func, select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.models.expense import FuelEntry, ServiceEntry
|
|
from app.schemas.expense import OdometerPrediction, OwnershipStats
|
|
|
|
|
|
async def get_ownership_stats(
|
|
session: AsyncSession, car_id: int, date_from: date, date_to: date
|
|
) -> OwnershipStats:
|
|
fuel_totals = await session.execute(
|
|
select(
|
|
func.coalesce(func.sum(FuelEntry.total_cost), 0),
|
|
func.coalesce(func.sum(FuelEntry.liters), 0),
|
|
func.count(FuelEntry.id),
|
|
func.min(FuelEntry.odometer),
|
|
func.max(FuelEntry.odometer),
|
|
).where(
|
|
FuelEntry.car_id == car_id,
|
|
FuelEntry.entry_date >= date_from,
|
|
FuelEntry.entry_date <= date_to,
|
|
)
|
|
)
|
|
fuel_cost, liters, fuel_count, min_odo, max_odo = fuel_totals.one()
|
|
|
|
service_totals = await session.execute(
|
|
select(func.coalesce(func.sum(ServiceEntry.total_cost), 0), func.count(ServiceEntry.id)).where(
|
|
ServiceEntry.car_id == car_id,
|
|
ServiceEntry.entry_date >= date_from,
|
|
ServiceEntry.entry_date <= date_to,
|
|
)
|
|
)
|
|
service_cost, service_count = service_totals.one()
|
|
|
|
distance_km = int(max_odo - min_odo) if min_odo is not None and max_odo is not None else 0
|
|
total_cost = Decimal(fuel_cost) + Decimal(service_cost)
|
|
avg_consumption = float(Decimal(liters) * Decimal(100) / distance_km) if distance_km else None
|
|
cost_per_km = float(total_cost / distance_km) if distance_km else None
|
|
|
|
return OwnershipStats(
|
|
car_id=car_id,
|
|
date_from=date_from,
|
|
date_to=date_to,
|
|
fuel_cost=fuel_cost,
|
|
service_cost=service_cost,
|
|
total_cost=total_cost,
|
|
liters=liters,
|
|
distance_km=distance_km,
|
|
avg_consumption_l_per_100km=avg_consumption,
|
|
cost_per_km=cost_per_km,
|
|
fuel_entries_count=fuel_count,
|
|
service_entries_count=service_count,
|
|
)
|
|
|
|
|
|
async def dataframe_from_query(session: AsyncSession, stmt: Select) -> pd.DataFrame:
|
|
result = await session.execute(stmt)
|
|
rows = result.mappings().all()
|
|
return pd.DataFrame(rows)
|
|
|
|
|
|
async def predict_odometer(session: AsyncSession, car_id: int) -> OdometerPrediction:
|
|
fuel = await dataframe_from_query(
|
|
session,
|
|
select(FuelEntry.entry_date.label("date"), FuelEntry.odometer.label("odometer")).where(
|
|
FuelEntry.car_id == car_id
|
|
),
|
|
)
|
|
service = await dataframe_from_query(
|
|
session,
|
|
select(ServiceEntry.entry_date.label("date"), ServiceEntry.odometer.label("odometer")).where(
|
|
ServiceEntry.car_id == car_id, ServiceEntry.odometer.is_not(None)
|
|
),
|
|
)
|
|
if fuel.empty and service.empty:
|
|
return OdometerPrediction(
|
|
car_id=car_id,
|
|
samples=0,
|
|
current_odometer=None,
|
|
predicted_today=None,
|
|
predicted_30_days=None,
|
|
avg_km_per_day=None,
|
|
avg_km_per_month=None,
|
|
confidence=0,
|
|
insight="Недостаточно данных: добавь одометр в заправках или сервисных записях.",
|
|
)
|
|
|
|
df = pd.concat([fuel, service]).dropna().drop_duplicates().sort_values("date")
|
|
df["date"] = pd.to_datetime(df["date"])
|
|
df = df.sort_values(["date", "odometer"]).drop_duplicates(subset=["date"], keep="last")
|
|
if len(df) < 2:
|
|
current = int(df.iloc[-1]["odometer"])
|
|
return OdometerPrediction(
|
|
car_id=car_id,
|
|
samples=len(df),
|
|
current_odometer=current,
|
|
predicted_today=current,
|
|
predicted_30_days=None,
|
|
avg_km_per_day=None,
|
|
avg_km_per_month=None,
|
|
confidence=0.2,
|
|
insight="Есть только одна точка пробега. Для прогноза нужны минимум две записи.",
|
|
)
|
|
|
|
first = df.iloc[0]
|
|
last = df.iloc[-1]
|
|
days = max((last["date"] - first["date"]).days, 1)
|
|
distance = max(int(last["odometer"] - first["odometer"]), 0)
|
|
km_per_day = distance / days
|
|
today = pd.Timestamp.utcnow().tz_localize(None).normalize()
|
|
days_since_last = max((today - last["date"]).days, 0)
|
|
predicted_today = int(last["odometer"] + km_per_day * days_since_last)
|
|
predicted_30 = int(predicted_today + km_per_day * 30)
|
|
confidence = min(0.95, 0.35 + len(df) * 0.035 + min(days, 365) / 730)
|
|
insight = (
|
|
"Пробег стабилен, прогноз надежный."
|
|
if confidence >= 0.75
|
|
else "Прогноз предварительный: точность вырастет после нескольких новых записей."
|
|
)
|
|
return OdometerPrediction(
|
|
car_id=car_id,
|
|
samples=len(df),
|
|
current_odometer=int(last["odometer"]),
|
|
predicted_today=predicted_today,
|
|
predicted_30_days=predicted_30,
|
|
avg_km_per_day=round(km_per_day, 1),
|
|
avg_km_per_month=round(km_per_day * 30.4, 1),
|
|
confidence=round(confidence, 2),
|
|
insight=insight,
|
|
)
|