"""
Vineyard Advisor tab — farmer-friendly dashboard + AI chatbot.
Loading strategy:
- Static sections render instantly (vine stage, shading text)
- Group A (IMS-only, ~200ms): weather, forecast, last rain
- Group B (network, ~1-2s): TB sensors, irrigation, energy — fills in async
Sections:
1. Vine stage — phenological stage + countdown to next
2. Weather forecast — week-ahead daily highs, rain/wind events
3. Panel shading — current conditions assessment
4. Tomorrow's plan — day-ahead DP trajectory with explanation
5. Energy generation — yesterday / today / tomorrow kWh
6. Irrigation — last water, soil status, when next needed
7. Chatbot — AI advisor
"""
from __future__ import annotations
import logging
import math
import threading
from datetime import date as _date_cls, timedelta as _td
import pandas as pd
import streamlit as st
from ui.bootstrap import ensure_ims_refresh_background, now_israel as _now_israel
def _get_plotly():
"""Lazy-load plotly only when a chart is actually rendered."""
try:
import plotly.express as px
return px
except ImportError:
return None
# ---------------------------------------------------------------------------
# Helpers — farmer-friendly formatting
# ---------------------------------------------------------------------------
def _temp_word(t: float) -> str:
if t >= 40: return "extreme heat"
if t >= 35: return "very hot"
if t >= 30: return "hot"
if t >= 25: return "warm"
if t >= 15: return "mild"
if t >= 5: return "cool"
return "cold"
def _soil_word(pct: float) -> str:
if pct < 12: return "very dry"
if pct < 18: return "dry"
if pct < 25: return "adequate"
if pct < 35: return "moist"
return "wet"
def _hours_ago_str(h: float) -> str:
if h < 1: return "less than 1 hour ago"
if h < 24: return f"{h:.0f} hours ago"
days = h / 24
if days < 2: return "yesterday"
return f"{days:.0f} days ago"
# ---------------------------------------------------------------------------
# Shared DataHub
# ---------------------------------------------------------------------------
def _vs_hub():
if "vs_hub" not in st.session_state:
from src.data_providers import DataHub
st.session_state["vs_hub"] = DataHub.default()
return st.session_state["vs_hub"]
# ---------------------------------------------------------------------------
# Shading gate assessment (uses same logic as control loop)
# ---------------------------------------------------------------------------
def _run_intervention_gate(
stage_id: str,
temp_c: float,
ghi: float | None,
hour: int,
) -> dict:
"""Run the InterventionGate logic and return a farmer-friendly result.
Returns dict with 'status' ("dormant", "blocked", "passed") and 'reason'.
Uses the same thresholds as the real-time control loop.
"""
from config.settings import (
NO_SHADE_BEFORE_HOUR,
SEMILLON_TRANSITION_TEMP_C,
SHADE_ELIGIBLE_CWSI_ABOVE,
SHADE_ELIGIBLE_GHI_ABOVE,
)
# Dormant — no canopy, shading is irrelevant (not harmful, just pointless)
if stage_id == "winter_dormancy":
return {"status": "dormant", "reason": "vine dormant"}
# Before allowed hour — morning light is critical for carbon fixation
if hour < NO_SHADE_BEFORE_HOUR:
return {
"status": "blocked",
"reason": (
f"morning light (before {NO_SHADE_BEFORE_HOUR}:00) is critical "
f"for carbon fixation. No shading before {NO_SHADE_BEFORE_HOUR}:00"
),
}
# Night / overcast — no meaningful sun
if ghi is not None and ghi < 100:
return {
"status": "blocked",
"reason": f"low radiation ({ghi:.0f} W/m²) — no meaningful sunlight to shade from",
}
# Below Rubisco transition — vine is light-limited (RuBP regime)
if temp_c < SEMILLON_TRANSITION_TEMP_C:
return {
"status": "blocked",
"reason": (
f"at {temp_c:.0f}°C the vine is light-limited (below {SEMILLON_TRANSITION_TEMP_C:.0f}°C "
f"Rubisco transition). Every photon helps — shading would reduce photosynthesis"
),
}
# GHI below stress threshold — not enough radiation to cause heat damage
if ghi is not None and ghi < SHADE_ELIGIBLE_GHI_ABOVE:
return {
"status": "blocked",
"reason": (
f"radiation ({ghi:.0f} W/m²) is below stress threshold "
f"({SHADE_ELIGIBLE_GHI_ABOVE:.0f} W/m²). Panels at full tracking"
),
}
# Heat stress proxy from air temperature (not true CWSI — no leaf temp available here)
heat_stress = max(0.0, min(1.0, (temp_c - 30.0) / 10.0))
if heat_stress < SHADE_ELIGIBLE_CWSI_ABOVE:
return {
"status": "blocked",
"reason": (
f"at {temp_c:.0f}°C, heat stress is moderate (index {heat_stress:.2f} "
f"< {SHADE_ELIGIBLE_CWSI_ABOVE:.2f}). Panels at full tracking"
),
}
# All conditions met — gate passes
return {
"status": "passed",
"reason": (
f"temperature {temp_c:.0f}°C above Rubisco transition, "
f"radiation {ghi:.0f} W/m², heat stress index {heat_stress:.2f}"
),
}
# ---------------------------------------------------------------------------
# Tomorrow's plan computation
# ---------------------------------------------------------------------------
def _compute_tomorrow_plan(tomorrow: _date_cls) -> dict:
"""Run DayAheadPlanner on tomorrow using IMS data for forecast proxy.
Uses last available day's temperature/GHI profile as a naive forecast
(persistence forecast). Returns dict with 'plan' key or 'error'.
"""
try:
hub = _vs_hub()
ims_df = hub.weather.get_dataframe()
if ims_df.empty:
return {"error": "No IMS data available."}
df = ims_df.copy()
if "timestamp_utc" in df.columns:
df["timestamp_utc"] = pd.to_datetime(df["timestamp_utc"], utc=True)
df = df.set_index("timestamp_utc")
# Use last full day as forecast proxy (persistence forecast)
last_day = df.index.max().normalize()
day_data = df[df.index.normalize() == last_day]
if len(day_data) < 10:
# Try day before
last_day = last_day - pd.Timedelta(days=1)
day_data = df[df.index.normalize() == last_day]
if len(day_data) < 10:
return {"error": "Not enough recent data for forecast."}
# Build 96-slot arrays from the proxy day
temps = [25.0] * 96
ghis = [0.0] * 96
for _, row in day_data.iterrows():
slot = row.name.hour * 4 + row.name.minute // 15
if 0 <= slot < 96:
if "air_temperature_c" in day_data.columns:
t = row.get("air_temperature_c")
if pd.notna(t):
temps[slot] = float(t)
if "ghi_w_m2" in day_data.columns:
g = row.get("ghi_w_m2")
if pd.notna(g):
ghis[slot] = float(g)
# Compute daily budget (simplified: use typical daily allocation)
from src.energy_budget import EnergyBudgetPlanner
planner_budget = EnergyBudgetPlanner()
annual = planner_budget.compute_annual_plan(tomorrow.year)
month_budget = annual["monthly_budgets"].get(tomorrow.month, 0.5)
daily_budget = month_budget / 30.0 # approximate daily share
# Run the day-ahead planner
from src.day_ahead_planner import DayAheadPlanner
planner = DayAheadPlanner()
plan = planner.plan_day(
target_date=tomorrow,
forecast_temps=temps,
forecast_ghi=ghis,
daily_budget_kwh=max(daily_budget, 0.1),
)
return {"plan": plan}
except Exception as exc:
return {"error": str(exc)}
# ---------------------------------------------------------------------------
# Group A: Fast data (IMS CSV only, ~200ms, no network)
# ---------------------------------------------------------------------------
def _fetch_group_a(today: _date_cls) -> dict:
"""Weather current + week view + last rain. All from cached IMS CSV."""
hub = _vs_hub()
ims_df = hub.weather.get_dataframe() # disk read (~100ms first time, cached after)
result: dict = {}
# Current weather
result["weather"] = hub.weather.get_current()
# Week view (last 7 days as proxy)
try:
if ims_df.empty:
result["week_forecast"] = {"error": "No IMS data."}
else:
df = ims_df
if "timestamp_utc" in df.columns:
df = df.copy()
df["timestamp_utc"] = pd.to_datetime(df["timestamp_utc"], utc=True)
df = df.set_index("timestamp_utc")
end = df.index.max()
start = end - pd.Timedelta(days=7)
week = df.loc[start:end]
if week.empty:
result["week_forecast"] = {"error": "Not enough data."}
else:
temp_col = next((c for c in week.columns if "temp" in c.lower() and "dew" not in c.lower() and "soil" not in c.lower()), None)
rain_col = next((c for c in week.columns if "rain" in c.lower()), None)
wind_col = next((c for c in week.columns if "wind" in c.lower() and "angle" not in c.lower()), None)
days_out = []
for day_date, day_data in week.resample("1D"):
if day_data.empty:
continue
d = {"date": day_date.strftime("%a %d/%m")}
if temp_col:
d["high"] = round(float(day_data[temp_col].max()), 1)
d["low"] = round(float(day_data[temp_col].min()), 1)
d["label"] = _temp_word(d["high"])
if rain_col:
total_rain = float(day_data[rain_col].sum())
if total_rain > 0.5:
d["rain_mm"] = round(total_rain, 1)
if wind_col:
max_wind = float(day_data[wind_col].max())
if max_wind > 8:
d["wind_ms"] = round(max_wind, 1)
days_out.append(d)
result["week_forecast"] = {"days": days_out, "note": "Based on recent IMS measurements (last 7 days)."}
except Exception as exc:
result["week_forecast"] = {"error": str(exc)}
# Last rain
try:
if not ims_df.empty:
df = ims_df
if "timestamp_utc" in df.columns:
df = df.copy()
df["timestamp_utc"] = pd.to_datetime(df["timestamp_utc"], utc=True)
df = df.set_index("timestamp_utc")
rain_col = next((c for c in df.columns if "rain" in c.lower()), None)
if rain_col:
rain = df[df[rain_col] > 0.2]
if not rain.empty:
last_ts = rain.index.max()
result["last_rain"] = {
"mm": round(float(rain.loc[last_ts, rain_col]), 1),
"hours_ago": round((pd.Timestamp.now(tz="UTC") - last_ts).total_seconds() / 3600, 1),
}
except Exception:
pass
return result
# ---------------------------------------------------------------------------
# Group B: Slow data (ThingsBoard + energy, ~1-2s network)
# ---------------------------------------------------------------------------
def _fetch_group_b(today: _date_cls) -> dict:
"""TB sensors + irrigation + energy predictions. Network-bound."""
from concurrent.futures import ThreadPoolExecutor, as_completed
hub = _vs_hub()
# Pre-load IMS DF once for all 3 energy predictions (avoids 3x CSV re-read)
ims_df = hub.weather.get_dataframe()
yesterday = str(today - _td(days=1))
today_str = str(today)
tomorrow = str(today + _td(days=1))
tasks = {
"sensors": lambda: hub.vine_sensors.get_snapshot(mode="dashboard"),
"energy_yesterday": lambda: hub.energy.predict(yesterday),
"energy_today": lambda: hub.energy.predict(today_str),
"energy_tomorrow": lambda: hub.energy.predict(tomorrow, ims_df=ims_df),
}
# Irrigation history from ThingsBoard
def _fetch_irrigation():
from datetime import datetime as _dt, timezone as _tz
from src.thingsboard_client import IRRIGATION_KEYS
try:
tb = hub.vine_sensors._client()
end = _dt.now(tz=_tz.utc)
start = end - _td(hours=48)
df = tb.get_timeseries("Irrigation1", IRRIGATION_KEYS, start, end)
if df.empty:
return {"error": "No irrigation data in last 48 hours."}
vol_col = next((c for c in df.columns if "volume" in c.lower()), None)
flow_col = next((c for c in df.columns if "flow" in c.lower()), None)
check_col = vol_col or flow_col
last_event = None
if check_col:
nonzero = df[df[check_col] > 0]
if not nonzero.empty:
last_ts = nonzero.index.max()
last_event = {
"hours_ago": round((pd.Timestamp.now(tz="UTC") - last_ts).total_seconds() / 3600, 1),
}
if vol_col and pd.notna(nonzero.loc[last_ts, vol_col]):
last_event["volume_l"] = round(float(nonzero.loc[last_ts, vol_col]), 1)
return {"last_event": last_event}
except Exception as exc:
return {"error": str(exc)}
tasks["irrigation"] = _fetch_irrigation
results = {}
with ThreadPoolExecutor(max_workers=6) as pool:
futures = {pool.submit(fn): name for name, fn in tasks.items()}
for f in as_completed(futures):
name = futures[f]
try:
results[name] = f.result()
except Exception as exc:
results[name] = {"error": str(exc)}
return results
# ---------------------------------------------------------------------------
# Main render function
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Control System Verification section (folded)
# ---------------------------------------------------------------------------
def _render_verification_section() -> None:
"""Render the control-system verification report as a folded expander."""
import json
from pathlib import Path
report_path = Path(__file__).resolve().parent.parent / "Data" / "verification_report.json"
with st.expander("Control System Verification Report", expanded=False):
# ── Methodology explanation ──────────────────────────────
st.markdown("""
**What this report does**
The verification script (`scripts/verify_control_system.py`) compares what the
DayAheadPlanner *would have commanded* against what the trackers *actually did*
over the last 10 days. It runs 10 automated checks:
| Step | Check | Data source |
|------|-------|-------------|
| 1 | Pull actual tracker angles | ThingsBoard Tracker501-509 |
| 2 | Pull actual energy production | ThingsBoard Plant asset (Wh) |
| 3 | Pull historical weather | Air1 ambient sensor (temp, PAR) |
| 4 | Run DayAheadPlanner per day | Real weather as perfect forecast |
| 5 | Compute astronomical angles | pvlib solar position model |
| 6 | Compare planned vs actual angles | MAE, max deviation, % within 2 deg |
| 7 | Validate InterventionGate decisions | No shade before 10:00, temp/GHI thresholds |
| 8 | Verify energy budget compliance | Daily cost <= daily budget ceiling |
| 9 | Cross-validate FvCB photosynthesis | A range, shading_helps consistency |
| 10 | Generate scorecard | Per-day and overall PASS/WARN/FAIL |
**How to interpret the results**
- **Angle alignment**: the MAE between the astronomical model and the real tracker.
Deviations > 2 deg are mostly at sunrise/sunset where the model clips at +/-60 deg
but the physical tracker can reach +/-73 deg.
- **Gate compliance**: verifies that no shading was triggered when it should not
have been (before 10:00, below 30 deg C, low GHI, May).
- **Budget compliance**: the planner must never exceed the daily energy ceiling.
- **FvCB consistency**: the Farquhar model must return physically plausible A values
and the `shading_helps` flag must agree with the temperature-based transition rule.
""")
st.markdown("---")
# ── Load and display report ──────────────────────────────
if not report_path.exists():
st.info(
"No verification report found. Run the verification script to generate one:\n\n"
"```\npython scripts/verify_control_system.py --days 10 "
"--output Data/verification_report.json\n```"
)
return
try:
report = json.loads(report_path.read_text())
except Exception as exc:
st.error(f"Failed to load report: {exc}")
return
sc = report.get("scorecard", {})
checks = sc.get("checks", {})
overall = sc.get("overall", "N/A")
generated = sc.get("generated_at", "unknown")
days = sc.get("days_analyzed", 0)
# ── Overall badge ────────────────────────────────────────
_badge_colors = {"PASS": "green", "WARN": "orange", "FAIL": "red"}
_badge_emoji = {"PASS": "white_check_mark", "WARN": "warning", "FAIL": "x"}
badge_color = _badge_colors.get(overall, "gray")
badge_emoji = _badge_emoji.get(overall, "question")
st.markdown(
f"### Overall: :{badge_emoji}: **{overall}**\n\n"
f"*{days} days analyzed — generated {generated[:16].replace('T', ' ')} UTC*"
)
# ── Per-check results ────────────────────────────────────
cols = st.columns(len(checks))
for col, (name, info) in zip(cols, checks.items()):
if not isinstance(info, dict):
continue
status = info.get("status", "N/A")
color = _badge_colors.get(status, "gray")
emoji = _badge_emoji.get(status, "question")
label = name.replace("_", " ").title()
with col:
st.markdown(f"**{label}**")
st.markdown(f":{emoji}: {status}")
# Show key metric
if "mae_deg" in info:
st.caption(f"MAE {info['mae_deg']}deg, {info.get('within_tolerance_pct', 0):.0f}% within 2deg")
elif "critical" in info:
st.caption(f"{info['critical']} critical, {info['warnings']} warn")
elif "days_exceeded" in info:
st.caption(f"{info['days_exceeded']} days exceeded")
elif "issues" in info:
st.caption(f"{info['issues']} issues, {info.get('errors', 0)} errors")
# ── Per-day table ────────────────────────────────────────
plans = report.get("plans", {})
violations = report.get("violations", [])
budget_results = report.get("budget_results", [])
if plans:
st.markdown("#### Per-Day Breakdown")
rows = []
budget_lookup = {r["date"]: r for r in budget_results}
for day_str in sorted(plans.keys()):
plan = plans[day_str]
if "error" in plan:
rows.append({
"Date": day_str, "Interventions": "ERR",
"Budget Used (%)": "-", "Gate Violations": "-",
})
continue
n_interv = plan.get("n_intervention_slots", 0)
util = plan.get("budget_utilisation_pct", 0)
day_viol = sum(1 for v in violations
if v.get("date") == day_str and v.get("severity") == "CRITICAL")
rows.append({
"Date": day_str,
"Interventions": n_interv,
"Budget Used (%)": f"{util:.1f}",
"Gate Violations": day_viol,
})
st.dataframe(pd.DataFrame(rows), hide_index=True, use_container_width=True)
# ── Angle alignment detail ───────────────────────────────
comp_summary = report.get("comparison_summary", {})
angle_info = checks.get("angle_alignment", {})
if angle_info:
st.markdown("#### Angle Alignment Detail")
st.markdown(
f"Compared **{comp_summary.get('matched_records', 0)}** planned slots "
f"against actual Tracker501 telemetry.\n\n"
f"- **MAE**: {angle_info.get('mae_deg', 'N/A')} deg\n"
f"- **Within +/-2 deg tolerance**: {angle_info.get('within_tolerance_pct', 'N/A')}%\n\n"
f"*Large deviations (>50 deg) are concentrated at sunrise/sunset slots "
f"where the pvlib model clips at +/-60 deg but the physical tracker "
f"reaches +/-73 deg. Midday alignment is typically within 1-2 deg.*"
)
# ── Re-run button ────────────────────────────────────────
st.markdown("---")
st.caption(
"To refresh this report, run from the terminal:\n\n"
"`python scripts/verify_control_system.py --days 10 "
"--output Data/verification_report.json`"
)
def render_tab_advisor() -> None:
today = _date_cls.today()
_now_vs = st.session_state.get("current_time_israel") or _now_israel()
st.header("Vineyard Advisor")
# ── Session state ─────────────────────────────────────────────────
if "chat_history" not in st.session_state:
st.session_state.chat_history = []
if "chatbot" not in st.session_state:
st.session_state.chatbot = None
if "chatbot_available" not in st.session_state:
st.session_state.chatbot_available = None
_GRP_A = "vs_grp_a"
_GRP_B = "vs_grp_b"
for k in (_GRP_A, _GRP_B):
if k not in st.session_state:
st.session_state[k] = None
# ── Pre-warm chatbot in background ────────────────────────────────
if "chatbot_warmup_started" not in st.session_state:
st.session_state.chatbot_warmup_started = True
def _warmup():
try:
from src.vineyard_chatbot import VineyardChatbot
bot = VineyardChatbot(hub=_vs_hub())
st.session_state.chatbot = bot
st.session_state.chatbot_available = True
# Try to warm up Gemini client (may fail without API key — that's OK)
if bot.has_api_key:
_ = bot.client
except Exception:
pass
threading.Thread(target=_warmup, daemon=True).start()
# ══════════════════════════════════════════════════════════════════
# 1. VINE STAGE (instant — no IO)
# ══════════════════════════════════════════════════════════════════
from src.phenology import estimate_stage_for_date, next_stage_for_date
stage = estimate_stage_for_date(today)
next_label, _, days_until = next_stage_for_date(today)
# ── Live vineyard camera + vine stage side by side ────────────
_cam_col, _stage_col = st.columns([1.2, 1])
with _cam_col:
import streamlit.components.v1 as _components
_components.html(
"""
<style>
.vineyard-cam {
width: 100%; border-radius: 8px;
object-fit: contain; background: #111;
}
</style>
<img id="vineCam" class="vineyard-cam"
src="https://app.solarwine.ai/images/yerucham/last_view.jpg"
alt="Vineyard live view" />
<script>
(function() {
var img = document.getElementById('vineCam');
var base = img.src.split('?')[0];
setInterval(function() {
img.src = base + '?' + Date.now();
}, 60000);
})();
</script>
""",
height=300,
)
st.caption("Live picture from our site in Yeruham. Vine: Chenin Blanc. Energy capacity: 100 kW.")
with _stage_col:
st.subheader(f"Vine stage: {stage.label}")
st.markdown(stage.description)
if days_until > 0:
st.caption(f"Next stage: **{next_label}** in ~{days_until} days")
st.caption(f"{_now_vs.strftime('%A %d %B %Y, %H:%M')} Israel time")
st.divider()
# ══════════════════════════════════════════════════════════════════
# GROUP A: Weather + Forecast (fast, ~200ms from cached CSV)
# ══════════════════════════════════════════════════════════════════
if st.session_state[_GRP_A] is None:
st.session_state[_GRP_A] = _fetch_group_a(today)
a = st.session_state[_GRP_A]
_wx = a.get("weather", {})
# Auto-refresh stale IMS data (>60 min) — at most once per session
_wx_age = _wx.get("age_minutes")
if _wx_age is not None and _wx_age > 60:
_ims_status = ensure_ims_refresh_background(days=3)
if _ims_status.get("running"):
st.info(f"Weather data is {_wx_age:.0f} min old — refreshing...")
elif _ims_status.get("ok") and not st.session_state.get("vs_ims_refreshed"):
st.session_state["vs_ims_refreshed"] = True
_vs_hub().weather._df_cache.invalidate("ims")
st.session_state[_GRP_A] = None
st.session_state[_GRP_B] = None
st.rerun()
elif _wx_age > 60:
st.caption(f"Weather data is {_wx_age:.0f} min old (IMS refresh attempted).")
# ── 2. WEATHER FORECAST ───────────────────────────────────────────
st.subheader("Weather — recent week")
_forecast = a.get("week_forecast", {})
if "error" in _forecast:
st.caption(f"Weather: {_forecast['error']}")
else:
days_list = _forecast.get("days", [])
if days_list:
n_cols = min(len(days_list), 7)
cols = st.columns(n_cols)
for i, day in enumerate(days_list[:7]):
with cols[i]:
st.markdown(f"**{day['date']}**")
high = day.get("high")
low = day.get("low")
if high is not None:
st.metric("High", f"{high:.0f} C", label_visibility="collapsed")
st.caption(f"{low:.0f}–{high:.0f} C ({day.get('label', '')})")
events = []
if day.get("rain_mm"):
events.append(f"Rain {day['rain_mm']} mm")
if day.get("wind_ms"):
events.append(f"Wind {day['wind_ms']:.0f} m/s")
if events:
st.caption(" | ".join(events))
if _forecast.get("note"):
st.caption(_forecast["note"])
# Current conditions — compact one-liner
# Extract once — used later in irrigation VPD calc
_rh = _wx.get("rh_percent") if "error" not in _wx else None
if "error" not in _wx:
_t = _wx.get("air_temperature_c")
_ws = _wx.get("wind_speed_ms")
parts = []
if _t is not None:
parts.append(f"**{_t:.0f} C** ({_temp_word(_t)})")
if _rh is not None:
parts.append(f"Humidity {_rh:.0f}%")
if _ws is not None:
parts.append(f"Wind {_ws:.1f} m/s")
age_str = f" — {_wx_age:.0f} min ago" if _wx_age else ""
if parts:
st.markdown("Now: " + " | ".join(parts) + age_str)
st.divider()
# ══════════════════════════════════════════════════════════════════
# 5. SHADING (instant — uses InterventionGate, same logic as control loop)
# ══════════════════════════════════════════════════════════════════
st.subheader("Panel shading")
_shading_assessed = False
if "error" not in _wx:
_t_now = _wx.get("air_temperature_c")
_ghi_now = _wx.get("ghi_w_m2")
_rh_now = _wx.get("rh_percent")
_wind_now = _wx.get("wind_speed_ms")
if _t_now is not None:
_shading_assessed = True
_gate_result = _run_intervention_gate(
stage_id=stage.id, temp_c=_t_now, ghi=_ghi_now, hour=_now_israel().hour,
)
if _gate_result["status"] == "dormant":
st.markdown(
"Panels at **full tracking** — maximum energy generation. "
"The vine is dormant (no leaves, no canopy) so panel position "
"has no effect on the plant. All energy goes to the grid."
)
elif _gate_result["status"] == "blocked":
reason = _gate_result["reason"]
st.markdown(f"Panels at **full tracking** — {reason}")
else:
# Gate passed — stress conditions met
st.markdown(
f"**Stress conditions detected** — "
f"{_gate_result['reason']}. "
f"The system may activate minimum-dose shading to protect "
f"the fruiting zone while preserving top-canopy productivity."
)
# Wind stow check
if _wind_now is not None:
from src.command_arbiter import CommandArbiter
wind_override = CommandArbiter.check_wind_stow(_wind_now)
if wind_override:
st.warning(
f"Wind stow active: {_wind_now:.1f} m/s — "
f"panels flat (0°) for structural safety. "
f"Overrides all other commands."
)
# Detailed gate explanation
with st.expander("How shading decisions work"):
st.markdown(
"Panels **always default to full astronomical tracking** "
"(following the sun for maximum energy). Shading is a rare, "
"minimum-dose intervention that activates only when **all** "
"of these conditions are true simultaneously:\n\n"
f"| Condition | Threshold | Current |\n"
f"|---|---|---|\n"
f"| Sunlight (GHI) | ≥ 400 W/m² | {_ghi_now:.0f} W/m² {'✓' if _ghi_now and _ghi_now >= 400 else '✗'} |\n"
f"| Leaf temperature | ≥ 30°C (Rubisco transition) | {_t_now:.0f}°C {'✓' if _t_now >= 30 else '✗'} |\n"
f"| Water stress (CWSI) | ≥ 0.4 | estimated from temp |\n"
f"| Morning light | After 10:00 | {'✓' if _now_israel().hour >= 10 else '✗'} |\n"
f"| Biology (FvCB model) | Shading helps photosynthesis | {'✓' if _t_now >= 30 and (_ghi_now or 0) >= 400 else '✗'} |\n\n"
"**Why?** Below 30°C, the vine is RuBP-limited — light is the "
"bottleneck, so reducing light (shading) hurts photosynthesis. "
"Above 30°C, the vine becomes Rubisco-limited — the enzyme is the "
"bottleneck, and reducing excess light can actually help by "
"lowering heat load on the fruiting zone."
)
if not _shading_assessed:
st.caption("No weather data available — cannot assess shading conditions.")
st.divider()
# ══════════════════════════════════════════════════════════════════
# 5b. TOMORROW'S PLAN (computed from IMS forecast + DayAheadPlanner)
# ══════════════════════════════════════════════════════════════════
st.subheader("Tomorrow's plan")
_tomorrow = today + _td(days=1)
_PLAN_KEY = "vs_tomorrow_plan"
try:
if _PLAN_KEY not in st.session_state:
st.session_state[_PLAN_KEY] = _compute_tomorrow_plan(_tomorrow)
_plan = st.session_state[_PLAN_KEY]
if _plan and "error" not in _plan:
plan_obj = _plan["plan"]
# Summary sentence
if plan_obj.n_intervention_slots == 0:
st.markdown(
f"**Full tracking all day** — panels follow the sun for maximum energy. "
f"No heat stress expected (forecast peak below shading threshold)."
)
else:
# Find intervention time window
int_slots = [s for s in plan_obj.slots if s.offset_deg > 0]
first_time = int_slots[0].time
last_time = int_slots[-1].time
avg_offset = sum(s.offset_deg for s in int_slots) / len(int_slots)
st.markdown(
f"**{plan_obj.n_intervention_slots} slots with shade** "
f"({first_time}–{last_time} UTC), "
f"average {avg_offset:.0f}° offset from tracking. "
f"Energy cost: {plan_obj.total_energy_cost_kwh:.3f} kWh "
f"({plan_obj.budget_utilisation_pct:.1f}% of daily budget)."
)
# Why this plan?
with st.expander("Why this plan?"):
st.markdown(
"The day-ahead planner uses dynamic programming to find the "
"optimal panel tilt trajectory for tomorrow. It balances two goals:\n\n"
"1. **Maximise energy** — panels track the sun (default)\n"
"2. **Protect the vine** — tilt panels to shade the fruiting zone "
"when heat stress is forecast\n\n"
"The planner only activates shading when **all** conditions are met:\n"
f"- Air temperature ≥ 30°C (Rubisco transition)\n"
f"- Solar radiation ≥ 400 W/m² (meaningful heat load)\n"
f"- Water stress indicator (CWSI) above threshold\n"
f"- Before 10:00 — no shading (morning light is critical)\n\n"
f"**Vine stage:** {plan_obj.stage_id.replace('_', ' ').title()}\n\n"
f"**Budget:** {plan_obj.daily_budget_kwh:.2f} kWh available "
f"(from hierarchical Year → Month → Week → Day allocation)"
)
# Slot-level detail
if plan_obj.slots:
slot_data = []
for s in plan_obj.slots:
if s.gate_passed or s.offset_deg > 0:
slot_data.append({
"Time (UTC)": s.time,
"Offset": f"{s.offset_deg:.0f}°",
"Energy cost": f"{s.energy_cost_kwh:.4f} kWh",
"Status": "Shade" if s.offset_deg > 0 else "Track",
})
if slot_data:
st.dataframe(pd.DataFrame(slot_data), hide_index=True)
else:
st.caption("All slots at full tracking — no interventions needed.")
else:
_err = _plan.get("error", "Could not compute plan.") if _plan else "No IMS data for planning."
st.caption(f"Plan unavailable: {_err}")
except Exception as _exc:
st.caption(f"Plan unavailable: {_exc}")
st.divider()
# ══════════════════════════════════════════════════════════════════
# GROUP B: Energy + Irrigation + Sensors (slow, ~1-2s network)
# ══════════════════════════════════════════════════════════════════
if st.session_state[_GRP_B] is None:
with st.spinner("Loading energy & irrigation data..."):
st.session_state[_GRP_B] = _fetch_group_b(today)
b = st.session_state[_GRP_B]
_sns = b.get("sensors", {})
# ── 3. ENERGY GENERATION ──────────────────────────────────────────
st.subheader("Energy generation")
_en_y = b.get("energy_yesterday", {})
_en_t = b.get("energy_today", {})
_en_m = b.get("energy_tomorrow", {})
en_cols = st.columns(3)
for col, label, data in [
(en_cols[0], "Yesterday", _en_y),
(en_cols[1], "Today (so far)", _en_t),
(en_cols[2], "Tomorrow (est.)", _en_m),
]:
with col:
st.markdown(f"**{label}**")
kwh = data.get("daily_kwh")
if kwh is None:
st.caption(data.get("error", "No data"))
else:
peak = data.get("peak_hour", "?")
st.metric("kWh", f"{kwh:.1f}")
st.caption(f"Peak at {peak}:00")
px = _get_plotly()
if px is not None:
chart_data = []
for label, data in [("Yesterday", _en_y), ("Today", _en_t), ("Tomorrow", _en_m)]:
kwh = data.get("daily_kwh")
if kwh is not None:
chart_data.append({"Day": label, "kWh": kwh})
if chart_data:
fig = px.bar(pd.DataFrame(chart_data), x="Day", y="kWh",
color_discrete_sequence=["#FF9800"])
fig.update_layout(height=200, margin=dict(t=10, b=10, l=40, r=10), showlegend=False)
st.plotly_chart(fig, use_container_width=True)
# Source attribution
src_y = _en_y.get("source", "")
src_t = _en_t.get("source", "")
if "ThingsBoard" in src_t:
st.caption("Source: live inverter data (ThingsBoard).")
else:
st.caption("Source: analytical estimate (48 kW system).")
st.caption("No energy was lost to shading today — panels at full tracking.")
st.divider()
# ── 4. IRRIGATION ─────────────────────────────────────────────────
st.subheader("Irrigation")
irr_cols = st.columns(3)
with irr_cols[0]:
st.markdown("**Last water**")
_irr = b.get("irrigation", {})
_last_rain = a.get("last_rain")
_irr_event = _irr.get("last_event") if isinstance(_irr, dict) and "error" not in _irr else None
if _irr_event:
ago = _irr_event.get("hours_ago", 0)
vol = _irr_event.get("volume_l")
vol_str = f" ({vol:.0f} L)" if vol else ""
st.markdown(f"Irrigated **{_hours_ago_str(ago)}**{vol_str}")
else:
st.caption("No irrigation in last 48 hours")
if _last_rain:
st.markdown(f"Rain **{_hours_ago_str(_last_rain['hours_ago'])}** ({_last_rain['mm']} mm)")
else:
st.caption("No recent rain")
with irr_cols[1]:
st.markdown("**Soil now**")
soil_m = _sns.get("treatment_soil_moisture_pct") if isinstance(_sns, dict) and "error" not in _sns else None
if soil_m is not None:
st.metric("Soil moisture", f"{soil_m:.0f}%")
st.caption(_soil_word(soil_m))
else:
st.caption("No soil data")
if _t_now is not None and _rh is not None:
es = 0.6108 * math.exp(17.27 * _t_now / (_t_now + 237.3))
vpd = max(es * (1 - _rh / 100), 0.0)
if vpd > 3.0:
st.caption("Air is **very dry** — high evaporation")
elif vpd > 2.0:
st.caption("Air is dry — moderate evaporation")
with irr_cols[2]:
st.markdown("**When next?**")
if soil_m is not None:
tomorrow_high = None
forecast_days = _forecast.get("days", []) if isinstance(_forecast, dict) else []
if forecast_days:
tomorrow_high = forecast_days[-1].get("high")
if soil_m < 12:
st.markdown("**Now** — soil is very dry")
elif soil_m < 18:
if tomorrow_high and tomorrow_high > 33:
st.markdown("**Tomorrow morning** — soil drying + hot weather ahead")
else:
st.markdown("**1-2 days** — soil getting dry")
elif soil_m < 25:
if tomorrow_high and tomorrow_high > 36:
st.markdown("**Tomorrow** possible — extreme heat forecast")
else:
st.markdown("**Not yet** — soil is fine")
else:
st.markdown("**Not needed** — soil is well-watered")
else:
st.caption("Cannot estimate — no soil data")
st.divider()
# ── REFRESH ───────────────────────────────────────────────────────
if st.button("Refresh all data", key="vs_refresh_all"):
st.session_state[_GRP_A] = None
st.session_state[_GRP_B] = None
st.session_state.pop("vs_ims_refreshed", None)
st.rerun()
st.divider()
# ══════════════════════════════════════════════════════════════════
# 6. CHATBOT
# ══════════════════════════════════════════════════════════════════
st.subheader("Ask the advisor")
st.markdown(
"Ask about shading decisions, vine health, weather, or irrigation. "
"The advisor uses live sensor data and models."
)
_qa_cols = st.columns(4)
with _qa_cols[0]:
if st.button("Should I shade?", key="qa_shade_now"):
st.session_state.chat_history.append(
{"role": "user", "content": "Should I shade right now? Check the current weather and tell me."})
with _qa_cols[1]:
if st.button("Tomorrow's outlook", key="qa_forecast"):
st.session_state.chat_history.append(
{"role": "user", "content": "What does tomorrow look like for the vineyard? Should I prepare for anything?"})
with _qa_cols[2]:
if st.button("Irrigation advice", key="qa_irrigation"):
st.session_state.chat_history.append(
{"role": "user", "content": "Check the soil moisture and weather. When should I irrigate next?"})
with _qa_cols[3]:
if st.button("Clear chat", key="qa_clear"):
st.session_state.chat_history = []
st.rerun()
st.divider()
# Lazy-init chatbot
def _ensure_chatbot():
if "chatbot" not in st.session_state:
st.session_state.chatbot = None
if "chatbot_available" not in st.session_state:
st.session_state.chatbot_available = None
if st.session_state.chatbot is not None:
return st.session_state.chatbot
try:
from src.vineyard_chatbot import VineyardChatbot
st.session_state.chatbot = VineyardChatbot(hub=_vs_hub())
st.session_state.chatbot_available = True
return st.session_state.chatbot
except Exception:
st.session_state.chatbot = None
st.session_state.chatbot_available = False
return None
def _render_tool_data(data: dict) -> None:
"""Farmer-friendly rendering — no 3D scenes, DLI, or technical charts."""
if not data or "error" in data:
return
# Energy prediction — simple metric
if "daily_kwh" in data and data["daily_kwh"] is not None:
st.metric("Daily energy", f"{data['daily_kwh']:.1f} kWh")
return
# Stress advisory summary
if "stress_profile" in data and data["stress_profile"].get("summary"):
st.info(data["stress_profile"]["summary"])
return
# Shading comparison — plain numbers, no technical labels
if "A_unshaded" in data and "A_shaded" in data:
change = data.get("A_change_pct", 0)
if change < -5:
st.warning(f"Shading would reduce vine activity by {abs(change):.0f}%")
elif change > 5:
st.success(f"Shading would help — vine activity improves by {change:.0f}%")
else:
st.info("Shading makes little difference right now.")
return
# Schedule table (e.g. irrigation schedule)
if "schedule" in data and isinstance(data["schedule"], list):
st.dataframe(pd.DataFrame(data["schedule"]), hide_index=True)
return
# Tabular data
if "rows" in data and isinstance(data["rows"], list) and data["rows"]:
st.dataframe(pd.DataFrame(data["rows"]), hide_index=True)
return
# Skip 3D scenes, DLI charts, angle sweeps, heatmaps — not farmer-friendly
if "scene_3d_html" in data or "angles" in data:
return
# Data summary
if "summarised" in data and data.get("columns"):
rows = [{"Column": k, **v} for k, v in data["columns"].items()]
if rows:
st.dataframe(pd.DataFrame(rows), hide_index=True)
return
def _render_grounding_metadata(entry: dict, msg_index: int = -1) -> None:
"""Render confidence badge, sources, caveats, and feedback under a response."""
confidence = entry.get("confidence", "")
sources = entry.get("sources", [])
caveats = entry.get("caveats", [])
violations = entry.get("rule_violations", [])
response_mode = entry.get("response_mode", "info")
# Dual-channel mode indicator
if response_mode == "advisory":
st.caption(":orange[Advisory — recommendation with reasoning]")
elif response_mode == "info" and confidence:
st.caption(":blue[Information — factual data]")
# Confidence badge
if confidence:
badge_colors = {
"high": "green",
"medium": "orange",
"low": "red",
"insufficient_data": "red",
}
color = badge_colors.get(confidence, "gray")
label = confidence.replace("_", " ").title()
st.caption(f":{color}[Confidence: {label}]")
# Sources
if sources:
st.caption(f"Source: {', '.join(sources)}")
# Caveats
for caveat in caveats:
st.caption(f"Note: {caveat}")
# Rule violations (warnings only — blocks replace the message)
for v in violations:
if v.get("severity") == "warn":
st.caption(f"Rule check ({v.get('rule', '?')}): {v.get('message', '')}")
# Feedback buttons
if msg_index >= 0:
_render_feedback_buttons(entry, msg_index)
def _render_feedback_buttons(entry: dict, msg_index: int) -> None:
"""Render thumbs up/down and flag buttons for a response."""
fb_key = f"fb_{msg_index}"
# Check if already rated
if entry.get("_feedback"):
fb = entry["_feedback"]
label = {"thumbs_up": "Helpful", "thumbs_down": "Not helpful", "flag_incorrect": "Flagged"}
st.caption(f"Feedback: {label.get(fb, fb)}")
return
cols = st.columns([1, 1, 1, 7])
with cols[0]:
if st.button("👍", key=f"{fb_key}_up", help="Helpful"):
_submit_feedback(entry, msg_index, "thumbs_up")
with cols[1]:
if st.button("👎", key=f"{fb_key}_down", help="Not helpful"):
_submit_feedback(entry, msg_index, "thumbs_down")
with cols[2]:
if st.button("🚩", key=f"{fb_key}_flag", help="Flag as incorrect"):
_submit_feedback(entry, msg_index, "flag_incorrect")
def _submit_feedback(entry: dict, msg_index: int, feedback_type: str) -> None:
"""Log feedback and mark the message as rated."""
try:
from src.chatbot.feedback import log_feedback
# Find the preceding user message
query = ""
if msg_index > 0:
for i in range(msg_index - 1, -1, -1):
prev = st.session_state.chat_history[i]
if prev.get("role") == "user":
query = prev.get("content", "")
break
log_feedback(
query=query,
response=entry.get("content", ""),
feedback=feedback_type,
confidence=entry.get("confidence", ""),
sources=entry.get("sources", []),
tool_calls=entry.get("tool_calls", []),
rule_violations=entry.get("rule_violations", []),
response_mode=entry.get("response_mode", ""),
)
except Exception as exc:
logging.getLogger(__name__).warning("Failed to log feedback: %s", exc)
# Mark as rated in session state
st.session_state.chat_history[msg_index]["_feedback"] = feedback_type
st.rerun()
# Display chat history
for _msg_idx, entry in enumerate(st.session_state.chat_history):
role = entry.get("role", "user")
with st.chat_message(role):
st.markdown(entry.get("content", ""))
if role == "assistant":
if entry.get("data"):
_render_tool_data(entry["data"])
_render_grounding_metadata(entry, msg_index=_msg_idx)
# Process pending message
_needs_response = (
st.session_state.chat_history
and st.session_state.chat_history[-1].get("role") == "user"
)
if _needs_response:
last_msg = st.session_state.chat_history[-1]["content"]
_hist_for_bot = st.session_state.chat_history[:-1]
with st.chat_message("assistant"):
import time as _time
t0 = _time.perf_counter()
spinner_msg = "Loading advisor..." if st.session_state.chatbot is None else "Thinking..."
try:
with st.spinner(spinner_msg):
chatbot = _ensure_chatbot()
resp = chatbot.chat(last_msg, history=_hist_for_bot) if chatbot else None
except Exception as _chat_exc:
resp = None
st.error(f"Advisor error: {_chat_exc}")
elapsed = _time.perf_counter() - t0
st.caption(f"{elapsed:.1f}s")
if resp is None:
st.markdown("Could not load the advisor. Check that a Google API key is set, or ask about vine biology rules.")
st.session_state.chat_history.append({
"role": "assistant",
"content": "Could not load the advisor. Check that a Google API key is set, or ask about vine biology rules.",
"data": {}, "tool_calls": [],
"confidence": "insufficient_data", "sources": [], "caveats": [],
})
else:
st.markdown(resp.message)
if resp.data:
_render_tool_data(resp.data)
_render_grounding_metadata({
"confidence": resp.confidence,
"sources": resp.sources,
"caveats": resp.caveats,
"rule_violations": resp.rule_violations,
})
st.session_state.chat_history.append({
"role": "assistant", "content": resp.message,
"data": resp.data if resp.data else {},
"tool_calls": resp.tool_calls,
"confidence": resp.confidence,
"sources": resp.sources,
"caveats": resp.caveats,
"rule_violations": resp.rule_violations,
"response_mode": getattr(resp, "response_mode", "info"),
})
st.rerun()
_user_input = st.chat_input("Ask the vineyard advisor...")
if _user_input:
st.session_state.chat_history.append({"role": "user", "content": _user_input})
st.rerun()
# ══════════════════════════════════════════════════════════════════
# CONTROL SYSTEM VERIFICATION (folded section at bottom)
# ══════════════════════════════════════════════════════════════════
st.divider()
_render_verification_section()
"""
Vineyard Advisor tab — farmer-friendly dashboard + AI chatbot.
Loading strategy:
- Static sections render instantly (vine stage, shading text)
- Group A (IMS-only, ~200ms): weather, forecast, last rain
- Group B (network, ~1-2s): TB sensors, irrigation, energy — fills in async
Sections:
1. Vine stage — phenological stage + countdown to next
2. Weather forecast — week-ahead daily highs, rain/wind events
3. Panel shading — current conditions assessment
4. Tomorrow's plan — day-ahead DP trajectory with explanation
5. Energy generation — yesterday / today / tomorrow kWh
6. Irrigation — last water, soil status, when next needed
7. Chatbot — AI advisor
"""
from __future__ import annotations
import logging
import math
import threading
from datetime import date as _date_cls, timedelta as _td
import pandas as pd
import streamlit as st
from ui.bootstrap import ensure_ims_refresh_background, now_israel as _now_israel
def _get_plotly():
"""Lazy-load plotly only when a chart is actually rendered."""
try:
import plotly.express as px
return px
except ImportError:
return None
# ---------------------------------------------------------------------------
# Helpers — farmer-friendly formatting
# ---------------------------------------------------------------------------
def _temp_word(t: float) -> str:
if t >= 40: return "extreme heat"
if t >= 35: return "very hot"
if t >= 30: return "hot"
if t >= 25: return "warm"
if t >= 15: return "mild"
if t >= 5: return "cool"
return "cold"
def _soil_word(pct: float) -> str:
if pct < 12: return "very dry"
if pct < 18: return "dry"
if pct < 25: return "adequate"
if pct < 35: return "moist"
return "wet"
def _hours_ago_str(h: float) -> str:
if h < 1: return "less than 1 hour ago"
if h < 24: return f"{h:.0f} hours ago"
days = h / 24
if days < 2: return "yesterday"
return f"{days:.0f} days ago"
# ---------------------------------------------------------------------------
# Shared DataHub
# ---------------------------------------------------------------------------
def _vs_hub():
if "vs_hub" not in st.session_state:
from src.data_providers import DataHub
st.session_state["vs_hub"] = DataHub.default()
return st.session_state["vs_hub"]
# ---------------------------------------------------------------------------
# Shading gate assessment (uses same logic as control loop)
# ---------------------------------------------------------------------------
def _run_intervention_gate(
stage_id: str,
temp_c: float,
ghi: float | None,
hour: int,
) -> dict:
"""Run the InterventionGate logic and return a farmer-friendly result.
Returns dict with 'status' ("dormant", "blocked", "passed") and 'reason'.
Uses the same thresholds as the real-time control loop.
"""
from config.settings import (
NO_SHADE_BEFORE_HOUR,
SEMILLON_TRANSITION_TEMP_C,
SHADE_ELIGIBLE_CWSI_ABOVE,
SHADE_ELIGIBLE_GHI_ABOVE,