# app.py
"""
Hardened Trip Planner Flask app:
- Uses Open-Meteo for free forecasts (with robust SSL handling).
- Uses Gemini via ChatGoogleGenerativeAI.invoke() when a valid GOOGLE_API_KEY is available.
- If Gemini key is missing/invalid, falls back to a local itinerary generator (deterministic).
- Never exposes full tracebacks to the user (friendly messages instead).
"""
from flask import Flask, request, render_template_string
import requests
import os
from datetime import datetime
from dateutil import parser as date_parser
import certifi # used to provide a trusted CA bundle for requests
from requests.exceptions import SSLError, RequestException
# LangChain Gemini wrapper
try:
from langchain_google_genai import ChatGoogleGenerativeAI
except Exception:
ChatGoogleGenerativeAI = None # handled later
app = Flask(__name__)
# ---------------- CONFIG (set your keys here or use env vars) ----------------
OPENWEATHER_API_KEY = os.environ.get("209688131a0268b51c101f612dca54ca", None) # optional, not used here
GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY", "AIzaSyBgxuSyNFW12uRObS0XVmyaAV3gKonG_UE")
# ---------------------------------------------------------------------------
INDEX_HTML = """
Hardened Trip Planner
Hardened Trip Planner — Weather + Itinerary
{% if notices %}
Notice:
{% for n in notices %}
- {{ n }}
{% endfor %}
{% endif %}
{% if weather_source %}
Weather source: {{ weather_source }}
{% endif %}
{% if weather_summary %}
Weather for {{ display_date }} — {{ display_city }}
{{ weather_summary }}
Decision:
{{ 'Good for travel' if is_good else 'Not ideal for travel' }}
{% endif %}
{% if itinerary %}
🧳 Suggested Itinerary
{{ itinerary }}
{% endif %}
{% if error %}
{{ error }}
{% endif %}
"""
# ---------------- Utilities: Open-Meteo (robust SSL) ----------------
def requests_get_with_cert_retry(url, params=None, timeout=10):
"""
Try requests.get with certifi bundle first (recommended).
If an SSL verification error occurs, retry with verify=False (insecure) and
return a tuple (response_json, insecure_flag, error_message_if_any).
"""
try:
r = requests.get(url, params=params, timeout=timeout, verify=certifi.where())
r.raise_for_status()
return r.json(), False, None
except SSLError as e:
# Retry insecurely but return a notice that we did that
try:
r = requests.get(url, params=params, timeout=timeout, verify=False)
r.raise_for_status()
return r.json(), True, f"SSL verification failed with certifi; retried with verify=False. (Reason: {e})"
except Exception as e2:
return None, False, f"Open-Meteo SSL retry failed: {e2}"
except RequestException as e:
return None, False, f"Request failed: {e}"
def open_meteo_geocode(city_name):
url = "https://geocoding-api.open-meteo.com/v1/search"
params = {"name": city_name, "count": 1}
data, insecure, err = requests_get_with_cert_retry(url, params=params)
if data is None:
raise RuntimeError(err or "Geocoding request failed.")
results = data.get("results") or []
if not results:
raise ValueError("City not found (Open-Meteo geocoding).")
first = results[0]
lat, lon = first["latitude"], first["longitude"]
admin1 = first.get("admin1")
country = first.get("country", "")
display = f"{first.get('name')}{', ' + admin1 if admin1 else ''}, {country}"
return lat, lon, display, insecure, None
def open_meteo_forecast(lat, lon, start_date, end_date):
url = "https://api.open-meteo.com/v1/forecast"
params = {
"latitude": lat,
"longitude": lon,
"daily": "temperature_2m_max,temperature_2m_min,precipitation_probability_mean,weathercode,windspeed_10m_max",
"timezone": "UTC",
"start_date": start_date.isoformat(),
"end_date": end_date.isoformat()
}
data, insecure, err = requests_get_with_cert_retry(url, params=params)
if data is None:
raise RuntimeError(err or "Forecast request failed.")
return data, insecure, None
WEATHERCODE_MAP = {
0: "Clear sky", 1: "Mainly clear", 2: "Partly cloudy", 3: "Overcast",
45: "Fog", 48: "Rime fog", 51: "Light drizzle", 53: "Moderate drizzle",
55: "Dense drizzle", 61: "Light rain", 63: "Moderate rain", 65: "Heavy rain",
71: "Snow", 73: "Moderate snow", 75: "Heavy snow", 95: "Thunderstorm", 99: "Severe thunderstorm"
}
def summarize_open_meteo(daily_json):
# daily_json is forecast["daily"]
# We expect single-day request; index 0 corresponds to requested date
try:
tmax = daily_json["temperature_2m_max"][0]
tmin = daily_json["temperature_2m_min"][0]
pop = daily_json.get("precipitation_probability_mean", [0])[0]
wcode = daily_json.get("weathercode", [None])[0]
wdesc = WEATHERCODE_MAP.get(wcode, f"Code {wcode}")
wind = daily_json.get("windspeed_10m_max", [None])[0]
summary = f"Temperature: {tmin}°C - {tmax}°C\nCondition: {wdesc}\nRain Probability: {pop}%\nWind (max): {wind} m/s"
metrics = {"temp": (tmax + tmin)/2.0, "pop": (pop or 0) / 100.0, "weather_main": wdesc, "wind": wind or 0.0}
return summary, metrics
except Exception as e:
raise RuntimeError(f"Failed parsing forecast data: {e}")
# -------------- Local deterministic itinerary fallback --------------
def local_itinerary(city, date_str, days, prefs):
"""
A deterministic, simple itinerary generator used when Gemini fails or key invalid.
This ensures user always gets a usable itinerary.
"""
# Minimal static content to avoid hallucination
lines = []
lines.append(f"Quick itinerary for {city} starting on {date_str} — {days} day(s). Preferences: {prefs or 'none'}.")
for d in range(days):
day_label = f"Day {d+1}"
lines.append(f"\n{day_label}:")
lines.append(" Morning: Visit a top-rated landmark or central park; short walk and coffee.")
lines.append(" Lunch: Try a popular local restaurant near the landmark.")
lines.append(" Afternoon: Museum / covered market / indoor experience (if raining).")
lines.append(" Evening: Scenic viewpoint or food street; end with a recommended cafe.")
lines.append(" Transport tip: Use local ride apps or short taxis for >3 km trips. Prefer walking for central areas.")
lines.append(" Safety tip: Keep a copy of ID, stay in well-lit areas at night.")
return "\n".join(lines)
# -------------- Gemini (LangChain) wrapper with graceful fallback --------------
def generate_itinerary_with_gemini(city_display, date_str, days, prefs):
"""
Tries to call Gemini via langchain_google_genai.ChatGoogleGenerativeAI.invoke().
If the LLM is unavailable, or API key invalid, returns None and an error message.
"""
# If wrapper not available
if ChatGoogleGenerativeAI is None:
return None, "LangChain Gemini wrapper not installed or import failed."
if not GOOGLE_API_KEY or GOOGLE_API_KEY.startswith("REPLACE_WITH"):
return None, "Gemini API key not configured or invalid."
try:
llm = ChatGoogleGenerativeAI(model="gemini-2.5-pro", temperature=0.25, google_api_key=GOOGLE_API_KEY)
except Exception as e:
return None, f"Could not initialize Gemini LLM: {e}"
prompt = (
f"You are a practical travel planner. Create a {days}-day itinerary for {city_display} starting on {date_str}.\n"
f"User preferences: {prefs or 'none'}.\n"
"- Provide 1-line summary, then day-by-day plan with morning/afternoon/evening slots.\n"
"- Add 2 recommended restaurants and 1 quick transport tip per day.\n"
"- Keep output factual and clear; do not invent opening hours.\n"
"Return plain text."
)
try:
# use invoke() per LangChain's new API
res = llm.invoke(prompt)
# The object returned by invoke may vary. Safely extract string content:
if hasattr(res, "content"):
# often a ChatResult with content attribute
content = res.content
elif isinstance(res, dict) and "output_text" in res:
content = res["output_text"]
else:
content = str(res)
return content, None
except Exception as e:
# Inspect message to decide if it's an auth error
msg = str(e)
if "API key not valid" in msg or "API_KEY_INVALID" in msg or "401" in msg or "403" in msg:
return None, "Gemini authentication failed (invalid/expired API key)."
return None, f"Gemini call failed: {msg}"
# -------------------- Flask routes --------------------
@app.route("/", methods=["GET"])
def index():
return render_template_string(INDEX_HTML)
@app.route("/plan", methods=["POST"])
def plan():
city = request.form.get("city", "").strip()
date_str = request.form.get("date", "").strip()
days = int(request.form.get("days", 1))
prefs = request.form.get("prefs", "").strip()
if not city or not date_str:
return render_template_string(INDEX_HTML, error="City and date are required.", city=city, date=date_str, days=days, prefs=prefs)
# parse date
try:
target_date = date_parser.parse(date_str).date()
except Exception:
return render_template_string(INDEX_HTML, error="Invalid date format (expected YYYY-MM-DD).", city=city, date=date_str, days=days, prefs=prefs)
notices = []
weather_summary = None
metrics = None
weather_source = None
insecure_flag = False
# Try Open-Meteo geocode + forecast with robust handling
try:
lat, lon, display_city, geocode_insecure, _ = open_meteo_geocode(city)
# request daily forecast for the same date
forecast_json, forecast_insecure, _ = open_meteo_forecast(lat, lon, target_date, target_date)
# combine insecure flags
insecure_flag = geocode_insecure or forecast_insecure
if insecure_flag:
notices.append("SSL certificate verification failed for Open-Meteo; requests were retried insecurely (verify=False). This is less secure — consider installing/updating system CA certs or `certifi`.")
# parse daily
daily = forecast_json.get("daily", {})
weather_summary, metrics = summarize_open_meteo(daily)
weather_source = "Open-Meteo (free)"
except Exception as e:
# parsing or request failed: show a friendly notice and continue to itinerary fallback
notices.append(f"Could not fetch weather data: {e}")
weather_summary = None
metrics = None
weather_source = None
display_city = city # fallback label
# Decide good/bad if metrics present; if absent, per your request always produce itinerary
if metrics:
# heuristics
is_good = True
if metrics.get("pop", 0) > 0.35: is_good = False
temp = metrics.get("temp")
if temp is not None and not (5 <= temp <= 35): is_good = False
if any(k.lower() in str(metrics.get("weather_main", "")).lower() for k in ["thunder", "storm", "snow", "heavy rain"]):
is_good = False
else:
is_good = True # user requested itinerary even if weather couldn't be fetched
# Try Gemini; if fails due to missing/invalid key or runtime error, fallback to local itinerary
itinerary = None
gemini_note = None
gemini_content, gemini_err = generate_itinerary_with_gemini(display_city, date_str, days, prefs)
if gemini_content:
itinerary = gemini_content
else:
# record a friendly note and generate local deterministic itinerary
gemini_note = gemini_err or "Unknown Gemini error."
notices.append(f"Gemini unavailable: {gemini_note} — falling back to local itinerary generator.")
itinerary = local_itinerary(display_city, date_str, days, prefs)
# Final render (no raw exceptions)
return render_template_string(
INDEX_HTML,
notices=notices,
weather_source=weather_source,
weather_summary=weather_summary,
is_good=is_good,
itinerary=itinerary,
display_date=target_date.isoformat(),
display_city=display_city,
city=city,
date=date_str,
days=days,
prefs=prefs
)
if __name__ == "__main__":
print("Starting hardened Trip Planner on http://127.0.0.1:5000")
print("If you see notices about SSL or Gemini key, follow printed instructions above the form.")
app.run(debug=False, host="127.0.0.1", port=5000)