Update app.py

app.py

@@ -98,100 +98,27 @@ def get_open_meteo_weather(city: str) -> str:
         return f"Error fetching weather data: {str(e)}"
 
 @tool
-def stargazing_advisor(city: str) -> str:
+def get_random_joke() -> str:
     """
-    Provides a stargazing recommendation for a given city by checking the forecasted daily
-    sunrise, sunset, and moon phase and the nighttime (21:00) hourly cloud cover using Open-Meteo's APIs.
+    Fetches a random joke from the Official Joke API.
     
-    Args:
-        city: The name of the city (e.g., "Erding").
-        
     Returns:
-        A string with forecast details and a recommendation on stargazing conditions.
+        A string containing the joke's setup and punchline, or an error message.
     """
     try:
-        # Step 1: Convert the city name to coordinates via the geocoding API.
-        geo_url = f"https://geocoding-api.open-meteo.com/v1/search?name={city}"
-        geo_resp = requests.get(geo_url)
-        geo_resp.raise_for_status()
-        geo_data = geo_resp.json()
-        results = geo_data.get("results")
-        if not results:
-            return f"Could not find coordinates for city: {city}."
-        first_result = results[0]
-        latitude = first_result.get("latitude")
-        longitude = first_result.get("longitude")
-        resolved_city = first_result.get("name", city)
+        # The API endpoint for a random joke:
+        url = "https://official-joke-api.appspot.com/random_joke"
+        response = requests.get(url)
+        response.raise_for_status()
+        joke_data = response.json()
         
-        # Step 2: Fetch daily forecast data (sunrise, sunset, moon_phase)
-        # Using forecast_days=2 (instead of 1) to ensure valid daily aggregation.
-        daily_url = (
-            f"https://api.open-meteo.com/v1/forecast?"
-            f"latitude={latitude}&longitude={longitude}"
-            f"&daily=sunrise,sunset,moon_phase"
-            f"&forecast_days=2"
-            f"&timezone=auto"
-        )
-        daily_resp = requests.get(daily_url)
-        daily_resp.raise_for_status()
-        daily_json = daily_resp.json()
-        daily_data = daily_json.get("daily", {})
-        times = daily_data.get("time", [])
-        if not times:
-            return "No daily forecast data available."
-        
-        # Use the first day's forecast.
-        forecast_date = times[0]  # e.g., "YYYY-MM-DD"
-        moon_phase = daily_data.get("moon_phase", [])[0]
-        sunrise = daily_data.get("sunrise", [])[0]
-        sunset = daily_data.get("sunset", [])[0]
-        
-        # Step 3: Get hourly forecast data for cloud cover.
-        hourly_url = (
-            f"https://api.open-meteo.com/v1/forecast?"
-            f"latitude={latitude}&longitude={longitude}"
-            f"&hourly=cloud_cover"
-            f"&timezone=auto"
-        )
-        hourly_resp = requests.get(hourly_url)
-        hourly_resp.raise_for_status()
-        hourly_data = hourly_resp.json().get("hourly", {})
-        hourly_times = hourly_data.get("time", [])
-        hourly_clouds = hourly_data.get("cloud_cover", [])
-        if not hourly_times or not hourly_clouds:
-            return "No hourly cloud cover data available."
-        
-        # Step 4: Find the cloud cover value near 21:00 local time on the forecast day.
-        target_time_str = f"{forecast_date}T21:00"
-        target_dt = datetime.datetime.fromisoformat(target_time_str)
-        time_objs = [datetime.datetime.fromisoformat(t) for t in hourly_times]
-        cloud_value = None
-        for t_obj, cloud in zip(time_objs, hourly_clouds):
-            if abs((t_obj - target_dt).total_seconds()) < 1800:  # within 30 minutes
-                cloud_value = cloud
-                break
-        if cloud_value is None:
-            closest_idx = min(range(len(time_objs)), key=lambda i: abs((time_objs[i] - target_dt).total_seconds()))
-            cloud_value = hourly_clouds[closest_idx]
-        
-        # Step 5: Evaluate stargazing conditions.
-        # Ideal conditions: cloud cover < 20% and a moon phase near new moon (<=0.2 or >=0.8, with 0.5 being full moon).
-        if cloud_value < 20 and (moon_phase <= 0.2 or moon_phase >= 0.8):
-            recommendation = "excellent"
-        elif cloud_value < 40 and (moon_phase <= 0.3 or moon_phase >= 0.7):
-            recommendation = "good"
-        else:
-            recommendation = "not ideal"
-        
-        return (
-            f"Stargazing Advisor for {resolved_city} on {forecast_date}:\n"
-            f"Sunrise: {sunrise}, Sunset: {sunset}\n"
-            f"Moon Phase: {moon_phase:.2f} (0=new, 0.5=full)\n"
-            f"Cloud Cover around 21:00: {cloud_value}%\n"
-            f"Tonight's stargazing conditions are {recommendation}."
-        )
+        setup = joke_data.get("setup")
+        punchline = joke_data.get("punchline")
+        if not setup or not punchline:
+            return "Couldn't find a complete joke."
+        return f"{setup} - {punchline}"
     except Exception as e:
-        return f"Error fetching forecast: {str(e)}"
+        return f"Error fetching joke: {str(e)}"
 
 final_answer = FinalAnswerTool()
 
@@ -214,7 +141,8 @@ with open("prompts.yaml", 'r') as stream:
     
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, get_current_time_in_timezone, image_generation_tool, search, get_open_meteo_weather, stargazing_advisor], ## add your tools here (don't remove final answer)
+    tools=[final_answer, get_current_time_in_timezone, image_generation_tool, search, get_open_meteo_weather,
+          get_random_joke], ## add your tools here (don't remove final answer)
     max_steps=6,
     verbosity_level=1,
     grammar=None,