Update app.py

app.py

@@ -9,8 +9,8 @@ from Gradio_UI import GradioUI
 
 # Below is an example of a tool that does nothing. Amaze us with your creativity !
 @tool
-def get_weather(city: str) -> str:  # Fixed comment syntax and function name
-    """A tool that retrieves the current weather for a city
+def get_weather_tool(city: str) -> str:
+    """A tool that retrieves the current weather for a city using DuckDuckGoSearchTool
     
     Args:
         city: the name of the city
@@ -19,43 +19,91 @@ def get_weather(city: str) -> str:  # Fixed comment syntax and function name
         str: Weather information for the specified city, or error message
     """
     try:
-        # Initialize the search tool correctly
+        # Create instance first, then call setup on the instance
         web_search_tool = DuckDuckGoSearchTool(max_results=3)
-        web_search_tool.setup()  # Call setup on the instance, not the class
+        web_search_tool.setup()  # Call setup on instance, not class
         
         # Search for weather information
-        search_query = f"current weather {city} temperature conditions"
+        search_query = f"current weather {city} temperature forecast"
         results = web_search_tool(search_query)
         
-        # Extract and format weather information
-        if results and len(results) > 0:
-            # Assuming results is a list of search result objects with 'snippet' or 'body' attributes
-            weather_info = ""
-            for result in results[:2]:  # Use top 2 results
-                if hasattr(result, 'snippet'):
-                    weather_info += result.snippet + " "
-                elif hasattr(result, 'body'):
-                    weather_info += result.body + " "
-                elif isinstance(result, dict):
-                    weather_info += result.get('snippet', result.get('body', str(result))) + " "
+        # Debug: Print raw results to understand the structure
+        print(f"Raw results type: {type(results)}")
+        print(f"Raw results: {results}")
+        
+        # Process results based on different possible return types
+        if results:
+            weather_info = []
+            
+            # Handle different result formats
+            if isinstance(results, list):
+                for i, result in enumerate(results[:3]):  # Use top 3 results
+                    print(f"Result {i}: {type(result)} - {result}")
+                    
+                    if isinstance(result, dict):
+                        # Handle dictionary results
+                        text = result.get('snippet', result.get('body', result.get('content', '')))
+                        title = result.get('title', '')
+                        url = result.get('url', '')
+                        
+                        # Combine title and text for better context
+                        combined = f"{title} {text}".strip()
+                        
+                    elif isinstance(result, str):
+                        # Handle string results
+                        combined = result
+                        
+                    else:
+                        # Handle object results with attributes
+                        combined = ""
+                        for attr in ['snippet', 'body', 'content', 'text', 'description']:
+                            if hasattr(result, attr):
+                                value = getattr(result, attr)
+                                if value:
+                                    combined += f"{value} "
+                        
+                        # Also try title
+                        if hasattr(result, 'title'):
+                            title = getattr(result, 'title')
+                            if title:
+                                combined = f"{title} {combined}"
+                    
+                    # Filter for weather-related content
+                    if combined and any(keyword in combined.lower() for keyword in 
+                                      ['temperature', 'weather', '°f', '°c', 'degrees', 'sunny', 
+                                       'cloudy', 'rain', 'forecast', 'humidity', 'wind']):
+                        weather_info.append(combined[:200])  # Limit length
+            
+            elif isinstance(results, str):
+                # Handle single string result
+                weather_info = [results[:300]]
             
-            if weather_info.strip():
-                return f"Weather in {city}: {weather_info.strip()}"
             else:
-                return f"Weather information found for {city}, but couldn't extract details. Raw results: {str(results)}"
+                # Handle other result types
+                weather_info = [str(results)[:300]]
+            
+            # Format final response
+            if weather_info:
+                return f"Weather in {city}: {' | '.join(weather_info)}"
+            else:
+                return f"Found search results for {city} but no clear weather information. Raw results: {str(results)[:200]}"
+        
         else:
-            return f"No weather information found for city '{city}'"
+            return f"No search results found for weather in {city}"
             
-    except ImportError:
-        return f"Error: DuckDuckGoSearchTool not available. Please install required dependencies."
+    except ImportError as e:
+        return f"Error: DuckDuckGoSearchTool not available. Import error: {str(e)}"
     except AttributeError as e:
-        return f"Error: Problem with search tool configuration: {str(e)}"
+        return f"Error: Problem with DuckDuckGoSearchTool setup or usage: {str(e)}"
+    except TypeError as e:
+        return f"Error: Incorrect parameters for DuckDuckGoSearchTool: {str(e)}"
     except Exception as e:
         return f"Error fetching weather information for city '{city}': {str(e)}"
 
 
 
 
+
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
     """A tool that fetches the current local time in a specified timezone.