planner v2 vc. porovnani

backend/app/routers/plan.py

@@ -41,12 +41,117 @@ class PlanningIntervalDto(BaseModel):
     )
 
 
-class CurrentPlanResponseModel(BaseModel):
+class PlanningBundleDto(BaseModel):
     run: dict[str, Any]
     intervals: list[PlanningIntervalDto]
     summary: dict[str, Any]
 
 
+class CurrentPlanResponseModel(PlanningBundleDto):
+    pass
+
+
+class ComparisonSlotDiffDto(BaseModel):
+    interval_start: str
+    active: dict[str, Any]
+    comparison: dict[str, Any]
+
+
+class PlanningCompareResponseModel(BaseModel):
+    active: PlanningBundleDto
+    comparison: PlanningBundleDto
+    diff: dict[str, Any]
+    slot_diffs: list[ComparisonSlotDiffDto]
+
+
+def _bundle_from_payload(payload: dict[str, Any], *, run_key: str) -> PlanningBundleDto:
+    run_raw = payload.get(run_key) or {}
+    if not isinstance(run_raw, dict):
+        run_raw = {}
+    intervals_raw = payload.get("intervals") or []
+    if not isinstance(intervals_raw, list):
+        intervals_raw = []
+    intervals = [PlanningIntervalDto.model_validate(d) for d in intervals_raw if isinstance(d, dict)]
+    summary = payload.get("summary") or {}
+    if not isinstance(summary, dict):
+        summary = {}
+    return PlanningBundleDto(run=run_raw, intervals=intervals, summary=summary)
+
+
+def _bundle_from_current(payload: dict[str, Any]) -> PlanningBundleDto:
+    return _bundle_from_payload(payload, run_key="run")
+
+
+def _bundle_from_debug(payload: dict[str, Any]) -> PlanningBundleDto:
+    return _bundle_from_payload(payload, run_key="planning_run")
+
+
+def _extract_run_id(bundle: PlanningBundleDto) -> int | None:
+    raw = bundle.run.get("id")
+    try:
+        return int(raw)
+    except (TypeError, ValueError):
+        return None
+
+
+def _build_plan_diff(
+    active: PlanningBundleDto,
+    comparison: PlanningBundleDto,
+) -> tuple[dict[str, Any], list[ComparisonSlotDiffDto]]:
+    active_by_ts = {i.interval_start: i for i in active.intervals}
+    compare_by_ts = {i.interval_start: i for i in comparison.intervals}
+    diffs: list[ComparisonSlotDiffDto] = []
+    interesting_keys = (
+        "battery_setpoint_w",
+        "battery_soc_target_pct",
+        "grid_setpoint_w",
+        "export_limit_w",
+        "export_mode",
+        "deye_physical_mode",
+        "deye_gen_cutoff_enabled",
+        "pv_a_curtailed_w",
+        "expected_cost_czk",
+    )
+    for ts, a in active_by_ts.items():
+        b = compare_by_ts.get(ts)
+        if b is None:
+            continue
+        active_payload = a.model_dump()
+        comparison_payload = b.model_dump()
+        if any(active_payload.get(k) != comparison_payload.get(k) for k in interesting_keys):
+            diffs.append(
+                ComparisonSlotDiffDto(
+                    interval_start=ts,
+                    active={k: active_payload.get(k) for k in interesting_keys},
+                    comparison={k: comparison_payload.get(k) for k in interesting_keys},
+                )
+            )
+
+    def _summary_num(bundle: PlanningBundleDto, key: str) -> float:
+        raw = bundle.summary.get(key)
+        try:
+            return float(raw) if raw is not None else 0.0
+        except (TypeError, ValueError):
+            return 0.0
+
+    active_cost = _summary_num(active, "total_expected_cost_czk")
+    compare_cost = _summary_num(comparison, "total_expected_cost_czk")
+    diff = {
+        "active_total_expected_cost_czk": active_cost,
+        "comparison_total_expected_cost_czk": compare_cost,
+        "total_expected_cost_czk": round(active_cost - compare_cost, 4),
+        "absolute_total_expected_cost_czk": round(abs(active_cost - compare_cost), 4),
+        "active_charge_slots": int(_summary_num(active, "charge_slots")),
+        "comparison_charge_slots": int(_summary_num(comparison, "charge_slots")),
+        "active_discharge_slots": int(_summary_num(active, "discharge_slots")),
+        "comparison_discharge_slots": int(_summary_num(comparison, "discharge_slots")),
+        "active_export_slots": int(_summary_num(active, "export_slots")),
+        "comparison_export_slots": int(_summary_num(comparison, "export_slots")),
+        "changed_slots": len(diffs),
+    }
+    return diff, diffs
+
+
 @router.get("/current", response_model=CurrentPlanResponseModel)
 async def get_current_plan(
     site_id: int,
@@ -69,14 +174,85 @@ async def get_current_plan(
     if bundle.get("error") == "no_active_plan":
         raise HTTPException(status_code=404, detail="No active plan")
 
-    intervals_raw = bundle.get("intervals") or []
-    if not isinstance(intervals_raw, list):
-        intervals_raw = []
-    intervals = [PlanningIntervalDto.model_validate(d) for d in intervals_raw if isinstance(d, dict)]
+    plan = _bundle_from_current(bundle)
     return CurrentPlanResponseModel(
-        run=bundle.get("run") or {},
-        intervals=intervals,
-        summary=bundle.get("summary") or {},
+        run=plan.run,
+        intervals=plan.intervals,
+        summary=plan.summary,
+    )
+
+
+@router.get("/compare", response_model=PlanningCompareResponseModel)
+async def get_plan_compare(
+    site_id: int,
+    pool: Annotated[asyncpg.Pool, Depends(get_pg_pool)],
+) -> PlanningCompareResponseModel:
+    async with pool.acquire() as conn:
+        site_ok = await conn.fetchval(
+            "SELECT EXISTS(SELECT 1 FROM ems.site WHERE id = $1)", site_id
+        )
+        if not site_ok:
+            raise HTTPException(status_code=404, detail="Site not found")
+
+        active_raw = await fetch_json(
+            conn,
+            "select ems.fn_plan_current_bundle($1::int)",
+            site_id,
+        )
+        if not isinstance(active_raw, dict):
+            active_raw = json.loads(active_raw)
+        if active_raw.get("error") == "no_active_plan":
+            raise HTTPException(status_code=404, detail="No active plan")
+
+        active = _bundle_from_current(active_raw)
+        active_run_id = _extract_run_id(active)
+        if active_run_id is None:
+            raise HTTPException(status_code=404, detail="No active plan")
+
+        compare_run_id = await conn.fetchval(
+            """
+            select pr.id
+            from ems.planning_run pr
+            where pr.site_id = $1::int
+              and pr.status = 'comparison'
+              and (pr.solver_params->>'comparison_of_run_id')::int = $2::int
+            order by pr.created_at desc
+            limit 1
+            """,
+            site_id,
+            active_run_id,
+        )
+        if compare_run_id is None:
+            compare_run_id = await conn.fetchval(
+                """
+                select pr.id
+                from ems.planning_run pr
+                where pr.site_id = $1::int
+                  and pr.status = 'comparison'
+                order by pr.created_at desc
+                limit 1
+                """,
+                site_id,
+            )
+        if compare_run_id is None:
+            raise HTTPException(status_code=404, detail="No comparison plan")
+        compare_raw = await fetch_json(
+            conn,
+            "select ems.fn_planning_run_debug($1::int)",
+            int(compare_run_id),
+        )
+    if not isinstance(compare_raw, dict):
+        compare_raw = json.loads(compare_raw)
+    if compare_raw is None:
+        raise HTTPException(status_code=404, detail="No comparison plan")
+
+    comparison = _bundle_from_debug(compare_raw)
+    diff, slot_diffs = _build_plan_diff(active, comparison)
+    return PlanningCompareResponseModel(
+        active=active,
+        comparison=comparison,
+        diff=diff,
+        slot_diffs=slot_diffs,
     )