Update app.py

app.py

@@ -10,6 +10,15 @@ from Gradio_UI import GradioUI
 # -----------------------------
 # LOCATION + TIMEZONE TOOLS
 # -----------------------------
+@tool
+def my_custom_tool(arg1:str, arg2:int)-> str: # it's important to specify the return type
+    # Keep this format for the tool description / args description but feel free to modify the tool
+    """A tool that does nothing yet 
+    Args:
+        arg1: the first argument
+        arg2: the second argument
+    """
+    return "What magic will you build ?"
 
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
@@ -26,250 +35,30 @@ def get_current_time_in_timezone(timezone: str) -> str:
     except Exception as e:
         return f"Error fetching time for timezone '{timezone}': {str(e)}"
 
-@tool
-def get_location() -> dict:
-    """Get user's approximate latitude and longitude."""
-    try:
-        res = requests.get("http://ip-api.com/json/")
-        data = res.json()
-        return {
-            "latitude": data["lat"],
-            "longitude": data["lon"]
-        }
-    except Exception as e:
-        return {"error": str(e)}
-
-@tool
-def get_local_timezone() -> str:
-    """Detects the user's local timezone based on IP."""
-    try:
-        res = requests.get("http://ip-api.com/json/")
-        data = res.json()
-        return data.get("timezone", "UTC")
-    except Exception as e:
-        return f"Error detecting timezone: {str(e)}"
-
-
-# -----------------------------
-# WEATHER TOOL (24H + UNCERTAINTY)
-# -----------------------------
-
-@tool
-def get_hourly_weather(latitude: float, longitude: float, timezone: str) -> list:
-    """Fetch hourly weather forecast for next 24 hours including uncertainty bands.
-        Args:
-        latitude: The latitude of the location.
-        longitude: The longitude of the location.
-        timezone: The IANA timezone string (e.g., 'America/Los_Angeles').
-
-    Returns:
-        A list of hourly weather data points with temperature, precipitation,
-        uncertainty bounds, and weather codes.
-    """
-    try:
-        url = "https://api.open-meteo.com/v1/forecast"
-
-        params = {
-            "latitude": latitude,
-            "longitude": longitude,
-            "hourly": "temperature_2m,precipitation,weathercode",
-            "forecast_days": 2,
-            "timezone": timezone
-        }
-
-        res = requests.get(url, params=params)
-        data = res.json()
-
-        hourly = data["hourly"]
-        tz = pytz.timezone(timezone)
-        now = datetime.datetime.now(tz)
-
-        result = []
-
-        for t, temp, precip, code in zip(
-            hourly["time"],
-            hourly["temperature_2m"],
-            hourly["precipitation"],
-            hourly["weathercode"]
-        ):
-            dt = datetime.datetime.fromisoformat(t)
-
-            if dt >= now and len(result) < 24:
-                # simple synthetic uncertainty band (±2°C)
-                result.append({
-                    "time": t,
-                    "temperature": temp,
-                    "temp_min": temp - 2,
-                    "temp_max": temp + 2,
-                    "precipitation": precip,
-                    "weathercode": code
-                })
-
-        return result
-
-    except Exception as e:
-        return [{"error": str(e)}]
-
-
-# -----------------------------
-# WEATHER CODE → ICON
-# -----------------------------
-
-def weather_icon(code):
-    if code == 0:
-        return "☀️"
-    elif code in [1, 2, 3]:
-        return "⛅"
-    elif code in [45, 48]:
-        return "🌫"
-    elif code in [51, 53, 55, 61, 63, 65]:
-        return "🌧"
-    elif code in [71, 73, 75]:
-        return "❄️"
-    elif code in [95]:
-        return "⛈"
-    else:
-        return "🌈"
-
-
-# -----------------------------
-# PLOT TOOL (ICONS + BANDS)
-# -----------------------------
-@tool
-def plot_weather(weather_data: list) -> str:
-    """Generate an SVG weather visualization with icons and uncertainty bands.
-
-    Args:
-        weather_data: A list of dictionaries containing hourly weather data. Each dict
-                      should have 'time', 'temperature', 'temp_min', 'temp_max',
-                      'precipitation', and 'weathercode'.
-
-    Returns:
-        A string file path to the generated SVG image.
-    """
-    import datetime
-    from xml.etree.ElementTree import Element, SubElement, ElementTree, tostring
-
-    # Helper: map weather code to icon
-    def weather_icon(code):
-        if code == 0:
-            return "☀️"
-        elif code in [1,2,3]:
-            return "⛅"
-        elif code in [45,48]:
-            return "🌫"
-        elif code in [51,53,55,61,63,65]:
-            return "🌧"
-        elif code in [71,73,75]:
-            return "❄️"
-        elif code in [95]:
-            return "⛈"
-        else:
-            return "🌈"
-
-    # SVG canvas size
-    width = 1200
-    height = 400
-    margin = 50
-
-    # Compute min/max for scaling
-    temps = [entry["temperature"] for entry in weather_data]
-    temp_min_vals = [entry["temp_min"] for entry in weather_data]
-    temp_max_vals = [entry["temp_max"] for entry in weather_data]
-    overall_min = min(temp_min_vals) - 2
-    overall_max = max(temp_max_vals) + 2
-
-    n = len(weather_data)
-    step_x = (width - 2*margin) / (n-1) if n > 1 else 1
-
-    def y_scale(temp):
-        # invert y axis (SVG 0,0 is top-left)
-        return height - margin - (temp - overall_min)/(overall_max - overall_min)*(height - 2*margin)
-
-    # Create root SVG
-    svg = Element('svg', width=str(width), height=str(height), xmlns="http://www.w3.org/2000/svg")
-
-    # Draw uncertainty band
-    points = []
-    for i, entry in enumerate(weather_data):
-        x = margin + i*step_x
-        y = y_scale(entry["temp_max"])
-        points.append(f"{x},{y}")
-    for i, entry in reversed(list(enumerate(weather_data))):
-        x = margin + i*step_x
-        y = y_scale(entry["temp_min"])
-        points.append(f"{x},{y}")
-    band = SubElement(svg, "polygon", points=" ".join(points), fill="#a0c4ff", opacity="0.3")
-
-    # Draw temperature line
-    temp_line_points = []
-    for i, entry in enumerate(weather_data):
-        x = margin + i*step_x
-        y = y_scale(entry["temperature"])
-        temp_line_points.append(f"{x},{y}")
-    SubElement(svg, "polyline", points=" ".join(temp_line_points),
-               fill="none", stroke="#0077b6", stroke_width="2")
-
-    # Draw precipitation bars
-    max_precip = max([entry["precipitation"] for entry in weather_data] + [1])
-    for i, entry in enumerate(weather_data):
-        x = margin + i*step_x - step_x*0.2
-        y = y_scale(overall_min) - (entry["precipitation"]/max_precip)*(height - 2*margin)
-        bar_height = (entry["precipitation"]/max_precip)*(height - 2*margin)
-        SubElement(svg, "rect", x=str(x), y=str(y), width=str(step_x*0.4),
-                   height=str(bar_height), fill="#00b4d8", opacity="0.4")
-
-    # Draw icons and x-axis labels
-    for i, entry in enumerate(weather_data):
-        x = margin + i*step_x
-        y_temp = y_scale(entry["temperature"])
-        # icon above temp
-        text = SubElement(svg, "text", x=str(x), y=str(y_temp - 10),
-                          font_size="20", text_anchor="middle")
-        text.text = weather_icon(entry["weathercode"])
-        # time label below
-        t_label = SubElement(svg, "text", x=str(x), y=str(height - margin + 20),
-                             font_size="12", text_anchor="middle")
-        t_label.text = entry["time"][11:16]
-
-    # Save SVG
-    file_path = "/mnt/data/weather_visual.svg"
-    tree = ElementTree(svg)
-    tree.write(file_path)
-
-    return file_path
-
-
-
-# -----------------------------
-# AGENT SETUP
-# -----------------------------
-
 final_answer = FinalAnswerTool()
-
-model = HfApiModel(
+model = InferenceClientModel(
     max_tokens=2096,
     temperature=0.5,
     model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
+    custom_role_conversions=None,
 )
 
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
-
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
-
+    
+# We're creating our CodeAgent
 agent = CodeAgent(
     model=model,
-    tools=[
-        final_answer,
-        get_location,
-        get_local_timezone,
-        get_hourly_weather,
-        plot_weather
-    ],
+    tools=[final_answer], # add your tools here (don't remove final_answer)
     max_steps=6,
     verbosity_level=1,
+    grammar=None,
+    planning_interval=None,
+    name=None,
+    description=None,
     prompt_templates=prompt_templates
 )
 
-GradioUI(agent).launch
+GradioUI(agent).launch()
+
+