Update app.py

app.py

@@ -1,17 +1,10 @@
 from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
-import datetime
-import requests
-import pytz
-import yaml
+from datetime import datetime
+import pytz, yaml, math, random
+from typing import Literal
 from tools.final_answer import FinalAnswerTool
-
 from Gradio_UI import GradioUI
 
-import math
-import random
-from typing import Literal
-
-
 @tool
 def get_approximate_integral(
     expr: str,
@@ -19,60 +12,34 @@ def get_approximate_integral(
     b: float,
     samples: int = 1000
 ) -> str:
-    """Approximate the definite integral of a function over [a, b].
-    
+    """Approximate the definite integral of f(x) over [a, b] via Monte Carlo.
+
     Args:
-        expr: A Python expression in variable `x`, e.g. "math.sin(x) + x**2".
-        a: Lower limit of integration.
-        b: Upper limit of integration.
-        method: Which algorithm to use:  
-            - "simpson": composite Simpson’s rule  
-            - "montecarlo": randomized Monte Carlo  
-            - "auto" (default): picks Simpson for smoothness, Monte Carlo otherwise.
-        samples: Number of panels (for Simpson) or random points (for Monte Carlo).
+        expr: Python expression in x, e.g. "math.sin(x)".
+        a: Lower limit.
+        b: Upper limit.
+        samples: Number of random samples.
     """
-    # Safely compile the expression
     code = compile(expr, "<string>", "eval")
     def f(x):
         return eval(code, {"__builtins__": {}}, {"x": x, "math": math})
-
-    # Monte Carlo fallback
-    inside = 0.0
+    total = 0.0
     for _ in range(samples):
-        x = random.uniform(a, b)
-        inside += f(x)
-    result = (b - a) * inside / samples
-    return f'{{"value": {result}, "method": "montecarlo", "samples": {samples}}}'
-
+        total += f(random.uniform(a, b))
+    result = (b - a) * total / samples
+    return f'{{"value": {result}, "samples": {samples}}}'
 
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
-    """A tool that fetches the current local time in a specified timezone.
-    Args:
-        timezone: A string representing a valid timezone (e.g., 'America/New_York').
-    """
+    """Fetch current time in a given TZ (e.g. 'America/New_York')."""
     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}"
+        now = datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        return now
     except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+        return f"Error: {e}"
 
-
-
-# If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
-# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 
-# final_answer = FinalAnswerTool()
 final_answer = FinalAnswerTool()
-    model = HfApiModel(
-    max_tokens=2096,
-    temperature=0.5,
-    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
-    custom_role_conversions=None,
-)
-
 
 model = HfApiModel(
     max_tokens=2096,
@@ -82,21 +49,20 @@ model = HfApiModel(
 )
 
 
-# Import tool from Hub
 image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
 tool_list = [
     final_answer,
     get_approximate_integral,
     get_current_time_in_timezone,
-    image_generation_tool,          # the hub‑loaded tool
-    DuckDuckGoSearchTool(),         # plain class → instantiate
+    image_generation_tool,
+    DuckDuckGoSearchTool(),
 ]
 
-# Load system prompt from prompt.yaml file
-with open("prompts.yaml", 'r') as stream:
-    prompt_templates = yaml.safe_load(stream)
-    
+with open("prompts.yaml") as f:
+    prompt_templates = yaml.safe_load(f)
+
+
 agent = CodeAgent(
     model=model,
     tools=tool_list,
@@ -110,4 +76,4 @@ agent = CodeAgent(
 )
 
 
-GradioUI(agent).launch()
+GradioUI(agent).launch()