Update app.py

updating the weather api to use an open spec and added funcitonality.

app.py

@@ -1,72 +1,202 @@
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
 import datetime
 import requests
 import pytz
 import yaml
 from tools.final_answer import FinalAnswerTool
-
 from Gradio_UI import GradioUI
+from typing import Dict, Tuple, Optional
+
+def get_coordinates(city: str) -> Optional[Tuple[float, float]]:
+    """Get coordinates for any city using Open-Meteo Geocoding API."""
+    try:
+        # Using Open-Meteo's free geocoding API
+        geocoding_url = f"https://geocoding-api.open-meteo.com/v1/search?name={city}&count=1&language=en&format=json"
+        response = requests.get(geocoding_url, timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("results"):
+                result = data["results"][0]
+                return (result["latitude"], result["longitude"])
+        return None
+    except Exception:
+        return None
 
-# Below is an example of a tool that does nothing. Amaze us with your creativity !
 @tool
-def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return type
-    #Keep this format for the description / args / args description but feel free to modify the tool
-    """A tool that does nothing yet 
+def get_weather(city: str) -> str:
+    """Get current weather information for a specified city.
+    
     Args:
-        arg1: the first argument
-        arg2: the second argument
+        city: Name of any city in the world
+    
+    Returns:
+        str: Weather information including temperature and conditions
     """
-    return "What magic will you build ?"
+    try:
+        # First get the coordinates for the city
+        coords = get_coordinates(city)
+        if not coords:
+            return f"Sorry, couldn't find coordinates for {city}. Please check the city name and try again."
+            
+        lat, lon = coords
+        
+        # Get weather using Open-Meteo API
+        api_url = "https://api.open-meteo.com/v1/forecast"
+        params = {
+            "latitude": lat,
+            "longitude": lon,
+            "current": "temperature_2m,wind_speed_10m,relative_humidity_2m",
+            "hourly": "temperature_2m,relative_humidity_2m,wind_speed_10m"
+        }
+        
+        response = requests.get(api_url, params=params, timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            current = data["current"]
+            
+            weather_report = (
+                f"Current weather in {city}:\n"
+                f"🌡️ Temperature: {current['temperature_2m']}°C\n"
+                f"💨 Wind Speed: {current['wind_speed_10m']} km/h\n"
+                f"💧 Humidity: {current.get('relative_humidity_2m', 'N/A')}%\n"
+                f"\nWould you like to check local bike trails? Use get_bike_trails('{city}')"
+            )
+            
+            return weather_report
+        else:
+            return f"Error fetching weather data. Status code: {response.status_code}"
+            
+    except Exception as e:
+        return f"Error fetching weather data: {str(e)}"
 
 @tool
-def get_current_time_in_timezone(timezone: str) -> str:
-    """A tool that fetches the current local time in a specified timezone.
+def check_biking_conditions(city: str) -> str:
+    """Check if current weather conditions are good for biking in specified city.
+    
     Args:
-        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+        city: Name of any city in the world
+    
+    Returns:
+        str: Assessment of biking conditions based on weather
     """
     try:
-        # Create timezone object
-        tz = pytz.timezone(timezone)
-        # Get current time in that timezone
-        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-        return f"The current local time in {timezone} is: {local_time}"
+        coords = get_coordinates(city)
+        if not coords:
+            return f"Sorry, couldn't find coordinates for {city}."
+            
+        lat, lon = coords
+        
+        api_url = "https://api.open-meteo.com/v1/forecast"
+        params = {
+            "latitude": lat,
+            "longitude": lon,
+            "current": "temperature_2m,wind_speed_10m",
+            "hourly": "temperature_2m,relative_humidity_2m,wind_speed_10m"
+        }
+        
+        response = requests.get(api_url, params=params, timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            current = data["current"]
+            temp = current['temperature_2m']
+            wind_speed = current['wind_speed_10m']
+            
+            # Assess conditions for biking
+            conditions = []
+            
+            if wind_speed > 20:
+                conditions.append(f"⚠️ Wind speeds are high ({wind_speed} km/h)")
+            if temp < 10:
+                conditions.append(f"🌡️ It's cold ({temp}°C) - dress warmly")
+            elif temp > 30:
+                conditions.append(f"🌡️ It's hot ({temp}°C) - stay hydrated")
+                
+            if conditions:
+                return f"Biking conditions in {city}:\n" + "\n".join(conditions)
+            else:
+                return f"👍 Great conditions for biking in {city}! {temp}°C with moderate wind speeds."
+                
+        else:
+            return f"Error checking conditions. Status code: {response.status_code}"
+            
     except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
-@tool
-def get_weather(city):
-    import requests
-    api_url = f"https://api.weather.com/v1/location/{city}?apiKey=YOUR_API_KEY"
-    response = requests.get(api_url)
-    if response.status_code == 200:
-        data = response.json()
-        return data.get("weather", "No weather information available")
-    else:
-        return "Error: Unable to fetch weather data."
-
-# Execute the function and prepare the final answer
-
-result = get_weather("New York")
-final_answer = f"The current weather in New York is: {result}"
-print(final_answer)
-
-final_answer = FinalAnswerTool()
-model = HfApiModel(
-max_tokens=2096,
-temperature=0.5,
-model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
-custom_role_conversions=None,
-)
+        return f"Error checking biking conditions: {str(e)}"
 
+# Keep mock trails data but make it more dynamic
+MOCK_TRAILS = {
+    # Dynamic trail generation based on city characteristics
+    "default_trails": [
+        {
+            "name": "{city} Riverside Path",
+            "difficulty": "Easy",
+            "length": "5.5 miles",
+            "description": "Scenic waterfront trail perfect for casual rides",
+            "features": ["Waterfront views", "Paved path", "Family-friendly"]
+        },
+        {
+            "name": "{city} Urban Loop",
+            "difficulty": "Moderate",
+            "length": "8.2 miles",
+            "description": "Popular city loop with diverse urban scenery",
+            "features": ["City views", "Mixed terrain", "Cultural spots"]
+        }
+    ]
+}
 
-# Import tool from Hub
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+@tool
+def get_bike_trails(city: str) -> str:
+    """Get information about bike trails in a specified city.
+    
+    Args:
+        city: Name of any city in the world
+    
+    Returns:
+        str: Information about available bike trails
+    """
+    # Generate dynamic trails for any city
+    trails = []
+    for trail_template in MOCK_TRAILS["default_trails"]:
+        trail = {
+            "name": trail_template["name"].format(city=city),
+            "difficulty": trail_template["difficulty"],
+            "length": trail_template["length"],
+            "description": trail_template["description"],
+            "features": trail_template["features"]
+        }
+        trails.append(trail)
+    
+    response = f"🚲 Suggested Bike Trails in {city}:\n\n"
+    
+    for trail in trails:
+        response += (
+            f"📍 {trail['name']}\n"
+            f"   • Difficulty: {trail['difficulty']}\n"
+            f"   • Length: {trail['length']}\n"
+            f"   • Description: {trail['description']}\n"
+            f"   • Features: {', '.join(trail['features'])}\n\n"
+        )
+    
+    response += "(Note: These are suggested routes based on typical city features. Always verify local trails and conditions.)"
+    
+    return response
 
+# Initialize agent with all tools
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
-    
+
 agent = CodeAgent(
     model=model,
-    tools=[final_answer], ## add your tools here (don't remove final answer)
+    tools=[
+        final_answer,
+        get_weather,
+        get_bike_trails,
+        check_biking_conditions,
+        get_current_time_in_timezone,
+        image_generation_tool
+    ],
     max_steps=6,
     verbosity_level=1,
     grammar=None,
@@ -76,5 +206,5 @@ agent = CodeAgent(
     prompt_templates=prompt_templates
 )
 
-
+# Launch Gradio UI
 GradioUI(agent).launch()