Update app.py

app.py

@@ -1,5 +1,3 @@
-### app_fixed.py ###
-
 import gradio as gr
 import pandas as pd
 import numpy as np
@@ -32,63 +30,56 @@ OVERPASS_URL = "https://maps.mail.ru/osm/tools/overpass/api/interpreter"
 ICON_URL = "https://raw.githubusercontent.com/basmilius/weather-icons/refs/heads/dev/production/fill/svg/"
 
 DEFAULT_LAT, DEFAULT_LON = 49.6116, 6.1319
+MIN_ALTITUDE_M = 300
+MAX_PEAKS = 100
 
 
 # --- UTILS ---
 
 def compute_bbox(lat, lon, dist_km):
-	"""Compute bounding box more reliably for any location."""
-	# Convert km to degrees (rough approximation)
-	# At equator: 1 degree ≈ 111 km
 	lat_delta = dist_km / 111.0
 	lon_delta = dist_km / (111.0 * np.cos(np.radians(lat)))
-	
-	south = lat - lat_delta
-	north = lat + lat_delta
+
+	south = max(lat - lat_delta, -90)
+	north = min(lat + lat_delta, 90)
 	west = lon - lon_delta
 	east = lon + lon_delta
-	
-	# Ensure longitude wraps properly
+
 	if west < -180:
 		west += 360
 	if east > 180:
 		east -= 360
-	
-	# Ensure latitude stays in valid range
-	south = max(south, -90)
-	north = min(north, 90)
-	
+
 	return f"{south},{west},{north},{east}"
 
 
 def get_elevation_from_srtm(lat, lon):
-	"""Get elevation from SRTM if within coverage area."""
 	if lat is None or lon is None:
 		return None
-	
-	# SRTM coverage: 60°N to 56°S
+
 	if -56 <= lat <= 60:
 		try:
 			alt = elevation_data.get_elevation(lat, lon)
-			if alt is not None and alt > 0:
+			if alt and alt > 0:
 				return alt
-		except Exception as ex:
-			print(f"SRTM error for {lat},{lon}: {ex}")
-	
+		except Exception:
+			pass
+
 	return None
 
 
 def get_peaks_from_overpass(lat, lon, dist_km):
-	"""Query Overpass API for nearby peaks and hills."""
 	bbox = compute_bbox(lat, lon, dist_km)
+
 	query = f"""
-		[out:json];
-		(
-		  nwr[natural=peak]({bbox});
-		  nwr[natural=hill]({bbox});
-		);
-		out body;
+	[out:json];
+	(
+	  nwr[natural=peak]({bbox});
+	  nwr[natural=hill]({bbox});
+	);
+	out body;
 	"""
+
 	try:
 		r = requests.get(OVERPASS_URL, params={"data": query}, timeout=30)
 		r.raise_for_status()
@@ -97,67 +88,57 @@ def get_peaks_from_overpass(lat, lon, dist_km):
 		print(f"Error fetching peaks: {e}")
 		return pd.DataFrame()
 
-	peaks = {"name": [], "latitude": [], "longitude": [], "altitude": []}
-	skipped = 0
-	processed = 0
-	max_peaks = 100  # Limit processing to avoid slowdowns
-	
+	rows = []
+
 	for e in data.get("elements", []):
-		# Stop if we've processed enough peaks
-		if processed >= max_peaks:
-			break
-			
 		lat_e, lon_e = e.get("lat"), e.get("lon")
-		
-		# Skip elements without valid coordinates
 		if lat_e is None or lon_e is None:
-			skipped += 1
 			continue
-			
+
 		tags = e.get("tags", {})
 		alt = None
-		
-		# Strategy 1: Try to get elevation from OSM tag first
+
 		ele = tags.get("ele")
 		if ele and str(ele).replace(".", "").replace("-", "").isnumeric():
 			alt = float(ele)
-		
-		# Strategy 2: If no OSM elevation, try SRTM as fallback
-		if alt is None or alt <= 10:
+
+		if alt is None or alt <= 0:
 			alt = get_elevation_from_srtm(lat_e, lon_e)
-		
-		# Skip peaks if both strategies failed to produce valid elevation
-		if alt is None or alt <= 10:
-			skipped += 1
+
+		if alt is None or alt < MIN_ALTITUDE_M:
 			continue
-		
-		peaks["latitude"].append(lat_e)
-		peaks["longitude"].append(lon_e)
-		peaks["name"].append(tags.get("name", "Unnamed Peak/Hill"))
-		peaks["altitude"].append(alt)
-		processed += 1
-	
-	if skipped > 0:
-		print(f"Skipped {skipped} peaks without complete data (coordinates or elevation)")
-	if processed >= max_peaks:
-		print(f"Reached limit of {max_peaks} peaks processed")
-
-	if not peaks["latitude"]:
+
+		rows.append({
+			"name": tags.get("name", "Unnamed Peak/Hill"),
+			"latitude": lat_e,
+			"longitude": lon_e,
+			"altitude": int(round(alt, 0)),
+		})
+
+	if not rows:
 		return pd.DataFrame()
 
-	df = pd.DataFrame(peaks)
-	df["altitude"] = df["altitude"].round(0).astype(int)
-	
+	df = pd.DataFrame(rows)
+
 	df["distance_m"] = df.apply(
-		lambda r: distance.distance((r["latitude"], r["longitude"]), (lat, lon)).m, axis=1
+		lambda r: distance.distance(
+			(r["latitude"], r["longitude"]), (lat, lon)
+		).m,
+		axis=1
 	)
+
+	df = (
+		df.sort_values("distance_m")
+		  .head(MAX_PEAKS)
+		  .reset_index(drop=True)
+	)
+
 	return df
 
 
-# --- WEATHER FETCH (STRING PARAMS VERSION) ---
+# --- WEATHER FETCH ---
 
 def get_weather_for_peaks_iteratively(df_peaks, min_snow_cm, max_results=20, max_requests=100):
-	"""Fetch weather for peaks with all params as strings to avoid iteration errors."""
 	if df_peaks.empty:
 		return pd.DataFrame()
 
@@ -181,32 +162,26 @@ def get_weather_for_peaks_iteratively(df_peaks, min_snow_cm, max_results=20, max
 			responses = openmeteo.weather_api(url, params=params)
 			if not responses:
 				continue
-			response = responses[0]
-			
-			hourly = response.Hourly()
+
+			hourly = responses[0].Hourly()
 			if hourly is None:
 				continue
 
 			idx = 0
-
-			temp_c = float(hourly.Variables(0).ValuesAsNumpy()[idx])
-			is_day = int(hourly.Variables(1).ValuesAsNumpy()[idx])
-			weather_code = int(hourly.Variables(2).ValuesAsNumpy()[idx])
-			snow_depth_m = float(hourly.Variables(3).ValuesAsNumpy()[idx])
-			snow_depth_cm = snow_depth_m * 100
+			snow_depth_cm = float(hourly.Variables(3).ValuesAsNumpy()[idx]) * 100
 
 			if snow_depth_cm >= min_snow_cm:
 				results.append({
 					**row.to_dict(),
-					"temp_c": temp_c,
-					"is_day": is_day,
-					"weather_code": weather_code,
-					"snow_depth_m": snow_depth_m,
-					"snow_depth_cm": int(np.round(snow_depth_cm, 0))
+					"temp_c": float(hourly.Variables(0).ValuesAsNumpy()[idx]),
+					"is_day": int(hourly.Variables(1).ValuesAsNumpy()[idx]),
+					"weather_code": int(hourly.Variables(2).ValuesAsNumpy()[idx]),
+					"snow_depth_m": snow_depth_cm / 100,
+					"snow_depth_cm": int(round(snow_depth_cm, 0)),
 				})
 
 		except Exception as e:
-			print(f"Error fetching weather for {row['name']} at {row['latitude']},{row['longitude']}: {e}")
+			print(f"Weather error for {row['name']}: {e}")
 
 		requests_made += 1
 
@@ -223,168 +198,65 @@ def format_weather_data(df):
 		code = str(int(row["weather_code"]))
 		tod = "day" if row["is_day"] == 1 else "night"
 		info = icons.get(code, {}).get(tod, {})
-		icon_filename = info.get("icon", "")
-		description = info.get("description", "Unknown")
-		return ICON_URL + icon_filename, description, icon_filename
+		return (
+			ICON_URL + info.get("icon", ""),
+			info.get("description", "Unknown"),
+			info.get("icon", "")
+		)
 
 	df[["weather_icon_url", "weather_desc", "weather_icon_name"]] = df.apply(
 		icon_mapper, axis=1, result_type="expand"
 	)
+
 	df["distance_km"] = (df["distance_m"] / 1000).round(1)
 	df["temp_c_str"] = df["temp_c"].round(0).astype(int).astype(str) + "°C"
 	return df
 
 
-def geocode_location(location_text):
-	try:
-		loc = geolocator.geocode(location_text, timeout=10)
-		if loc:
-			return loc.latitude, loc.longitude, f"Found: {loc.address}"
-		return None, None, f"Location '{location_text}' not found."
-	except Exception as e:
-		return None, None, f"Geocoding error: {e}"
-
-
 # --- CORE LOGIC ---
 
 def find_snowy_peaks(min_snow_cm, radius_km, lat, lon):
 	if lat is None or lon is None:
-		fig = create_empty_map(DEFAULT_LAT, DEFAULT_LON)
-		fig.update_layout(title_text="Enter valid coordinates.")
-		return fig, "Please enter coordinates."
-
-	if not (-90 <= lat <= 90 and -180 <= lon <= 180):
-		fig = create_empty_map(DEFAULT_LAT, DEFAULT_LON)
-		fig.update_layout(title_text="Invalid coordinates.")
-		return fig, "Coordinates out of range."
+		return create_map_with_center(DEFAULT_LAT, DEFAULT_LON), "Invalid coordinates."
 
 	df_peaks = get_peaks_from_overpass(lat, lon, radius_km)
 	if df_peaks.empty:
-		fig = create_map_with_center(lat, lon)
-		fig.update_layout(title_text=f"No peaks found within {radius_km} km.")
-		return fig, f"No peaks found within {radius_km} km."
+		return create_map_with_center(lat, lon), "No peaks found."
 
-	df_peaks = df_peaks.sort_values("distance_m").reset_index(drop=True)
 	df_weather = get_weather_for_peaks_iteratively(df_peaks, min_snow_cm)
-
 	if df_weather.empty:
-		fig = create_map_with_center(lat, lon)
-		fig.update_layout(title_text=f"No snowy peaks ≥ {min_snow_cm} cm.")
-		return fig, f"No peaks met the ≥ {min_snow_cm} cm snow requirement."
+		return create_map_with_center(lat, lon), "No snowy peaks found."
 
 	df_final = format_weather_data(df_weather)
-	fig = create_map_with_results(lat, lon, df_final)
-	fig.update_layout(title_text=f"Found {len(df_final)} snowy peaks!")
-	msg = f"🎉 Showing {len(df_final)} snowy peaks with ≥ {min_snow_cm} cm of snow."
-	return fig, msg
+	return create_map_with_results(lat, lon, df_final), f"Showing {len(df_final)} snowy peaks."
 
 
 # --- MAP HELPERS ---
 
-def create_empty_map(lat, lon):
-	fig = go.Figure()
-	fig.update_layout(
-		map=dict(style="open-street-map", center={"lat": lat, "lon": lon}, zoom=8),
-		margin={"r": 0, "t": 40, "l": 0, "b": 0},
-		height=1024,
-		width=1024,
-	)
-	return fig
-
-
 def create_map_with_center(lat, lon):
-	fig = go.Figure(
-		go.Scattermap(
-			lat=[lat],
-			lon=[lon],
-			mode="markers",
-			marker=dict(size=24, color="white", opacity=0.8),
-			hoverinfo="skip",
-		)
-	)
-	fig.add_trace(
-		go.Scattermap(
-			lat=[lat],
-			lon=[lon],
-			mode="markers",
-			marker=dict(size=12, color="red"),
-			text=["Search Center"],
-			hoverinfo="text",
-		)
-	)
-	fig.update_layout(
-		map=dict(style="open-street-map", center={"lat": lat, "lon": lon}, zoom=8),
-		margin={"r": 0, "t": 40, "l": 0, "b": 0},
-		height=1024,
-		width=1024,
-	)
+	fig = go.Figure(go.Scattermap(lat=[lat], lon=[lon], mode="markers"))
+	fig.update_layout(map=dict(style="open-street-map", center={"lat": lat, "lon": lon}, zoom=8))
 	return fig
 
 
-def create_map_with_results(lat, lon, df_final):
+def create_map_with_results(lat, lon, df):
 	fig = go.Figure()
-	
-	# Add white halos for peaks
-	fig.add_trace(
-		go.Scattermap(
-			lat=df_final["latitude"],
-			lon=df_final["longitude"],
-			mode="markers",
-			marker=dict(size=24, color="white", opacity=0.8),
-			hoverinfo="skip",
-		)
-	)
-	
-	# Add peak markers with weather info in hover (no HTML icons)
-	fig.add_trace(
-		go.Scattermap(
-			lat=df_final["latitude"],
-			lon=df_final["longitude"],
-			mode="markers",
-			marker=dict(size=12, color="blue"),
-			customdata=df_final[
-				["name", "altitude", "distance_km", "snow_depth_cm", "weather_desc", 
-				 "temp_c_str"]
-			],
-			hovertemplate=(
-				"<b>%{customdata[0]}</b><br>"
-				"Altitude: %{customdata[1]} m<br>"
-				"Distance: %{customdata[2]} km<br>"
-				"<b>❄️ Snow: %{customdata[3]} cm</b><br>"
-				"Weather: %{customdata[4]}<br>"
-				"🌡 Temp: %{customdata[5]}<extra></extra>"
-			),
-		)
-	)
-	
-	# Add search center with halo
-	fig.add_trace(
-		go.Scattermap(
-			lat=[lat],
-			lon=[lon],
-			mode="markers",
-			marker=dict(size=24, color="white", opacity=0.8),
-			hoverinfo="skip",
-		)
-	)
-	fig.add_trace(
-		go.Scattermap(
-			lat=[lat],
-			lon=[lon],
-			mode="markers",
-			marker=dict(size=12, color="red"),
-			text=["Search Center"],
-			hoverinfo="text",
-		)
-	)
-	
-	fig.update_layout(
-		map=dict(style="open-street-map", center={"lat": lat, "lon": lon}, zoom=9),
-		margin={"r": 0, "t": 40, "l": 0, "b": 0},
-		height=1024,
-		width=1024,
-		showlegend=False,
-	)
+	fig.add_trace(go.Scattermap(
+		lat=df["latitude"],
+		lon=df["longitude"],
+		mode="markers",
+		marker=dict(size=12, color="blue"),
+		customdata=df[["name", "altitude", "distance_km", "snow_depth_cm", "weather_desc", "temp_c_str"]],
+		hovertemplate=(
+			"<b>%{customdata[0]}</b><br>"
+			"Altitude: %{customdata[1]} m<br>"
+			"Distance: %{customdata[2]} km<br>"
+			"❄️ Snow: %{customdata[3]} cm<br>"
+			"Weather: %{customdata[4]}<br>"
+			"🌡 %{customdata[5]}<extra></extra>"
+		),
+	))
+	fig.update_layout(map=dict(style="open-street-map", center={"lat": lat, "lon": lon}, zoom=9))
 	return fig
 
 
@@ -392,32 +264,19 @@ def create_map_with_results(lat, lon, df_final):
 
 with gr.Blocks(theme=gr.themes.Soft(), title="Snow Finder") as demo:
 	gr.Markdown("# ☃️ Snow Finder for Families")
-	gr.Markdown("Find nearby snowy peaks perfect for sledding and snowmen!")
-
-	with gr.Row():
-		with gr.Column(scale=1):
-			location_search = gr.Textbox(label="Search Location")
-			search_location_btn = gr.Button("🔍 Find Location")
-
-			lat_input = gr.Number(value=DEFAULT_LAT, label="Latitude", precision=4)
-			lon_input = gr.Number(value=DEFAULT_LON, label="Longitude", precision=4)
-			snow_slider = gr.Radio(choices=[1, 2, 3, 4, 5, 6], value=1, label="Min Snow (cm)")
-			radius_slider = gr.Radio(choices=[10, 20, 30, 40, 50, 60], value=30, label="Radius (km)")
-			search_button = gr.Button("❄️ Find Snow!", variant="primary")
-			status_output = gr.Textbox(lines=4, interactive=False)
-
-		with gr.Column(scale=2):
-			init_fig = create_map_with_center(DEFAULT_LAT, DEFAULT_LON)
-			init_fig.update_layout(title_text="Luxembourg City – Click 'Find Snow!' to start")
-			map_plot = gr.Plot(init_fig, label="Map")
-
-	search_location_btn.click(
-		fn=geocode_location, inputs=[location_search], outputs=[lat_input, lon_input, status_output]
-	)
+
+	lat_input = gr.Number(value=DEFAULT_LAT, label="Latitude")
+	lon_input = gr.Number(value=DEFAULT_LON, label="Longitude")
+	snow_slider = gr.Radio([1, 2, 3, 4, 5, 6], value=1, label="Min Snow (cm)")
+	radius_slider = gr.Radio([10, 20, 30, 40, 50, 60], value=30, label="Radius (km)")
+	search_button = gr.Button("❄️ Find Snow!")
+	map_plot = gr.Plot()
+	status = gr.Textbox()
+
 	search_button.click(
 		fn=find_snowy_peaks,
 		inputs=[snow_slider, radius_slider, lat_input, lon_input],
-		outputs=[map_plot, status_output],
+		outputs=[map_plot, status],
 	)
 
 if __name__ == "__main__":