party planner

app.py

@@ -8,288 +8,6 @@ from tools.final_answer import FinalAnswerTool
 
 from Gradio_UI import GradioUI
 
-# Below is an example of a tool that does nothing. Amaze us with your creativity !
-@tool
-def my_weather_tool(location: str) -> str:
-    """A tool that fetches the current weather for a location using Tomorrow.io API.
-    
-    Args:
-        location: Location name (e.g., 'New York') or lat,lon coordinates (e.g., '40.7128,-74.0060')
-    """
-    # Get API key from environment
-    api_key = os.getenv("TOMORROW_API_KEY")
-    if not api_key:
-        return "Error: TOMORROW_API_KEY environment variable is not set. Please set it to use this tool."
-    
-    # API endpoint
-    geocoding_endpoint = "https://api.tomorrow.io/v4/geocoding"
-    realtime_endpoint = "https://api.tomorrow.io/v4/weather/realtime"
-    
-    # Weather code to description mapping
-    weather_codes = {
-        0: "Unknown",
-        1000: "Clear, Sunny",
-        1100: "Mostly Clear",
-        1101: "Partly Cloudy",
-        1102: "Mostly Cloudy",
-        1001: "Cloudy",
-        2000: "Fog",
-        2100: "Light Fog",
-        4000: "Drizzle",
-        4001: "Rain",
-        4200: "Light Rain",
-        4201: "Heavy Rain",
-        5000: "Snow",
-        5001: "Flurries",
-        5100: "Light Snow",
-        5101: "Heavy Snow",
-        6000: "Freezing Drizzle",
-        6001: "Freezing Rain",
-        6200: "Light Freezing Rain",
-        6201: "Heavy Freezing Rain",
-        7000: "Ice Pellets",
-        7101: "Heavy Ice Pellets",
-        7102: "Light Ice Pellets",
-        8000: "Thunderstorm"
-    }
-    
-    try:
-        # Determine if input is coordinates or location name
-        if "," in location and all(
-            part.replace("-", "").replace(".", "").strip().isdigit() 
-            for part in location.split(",", 1)
-        ):
-            # Input appears to be coordinates
-            lat, lon = map(float, location.split(",", 1))
-            location_name = f"Coordinates ({lat}, {lon})"
-        else:
-            # Input is a location name, geocode it
-            params = {
-                "apikey": api_key,
-                "query": location
-            }
-            
-            response = requests.get(realtime_endpoint, params=params)
-            response.raise_for_status()
-            
-            data = response.json()
-            
-            # Check if we got valid results
-            if data.get("data") and len(data["data"]) > 0:
-                # Use the first (best) match
-                location_data = data["data"][0]
-                lat = location_data["latitude"]
-                lon = location_data["longitude"]
-                location_name = f"{location_data.get('name', '')}, {location_data.get('country', '')}"
-            else:
-                return f"Location '{location}' not found. Please try a different location name or coordinates."
-        
-        # Get current weather data
-        params = {
-            "apikey": api_key,
-            "location": f"{lat},{lon}",
-            "units": "metric"
-        }
-        
-        response = requests.get(realtime_endpoint, params=params)
-        response.raise_for_status()
-        
-        # Parse weather data
-        weather_data = response.json()
-        values = weather_data.get("data", {}).get("values", {})
-        
-        # Get timestamp
-        timestamp = weather_data.get("data", {}).get("time")
-        if timestamp:
-            try:
-                dt = datetime.datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
-                formatted_time = dt.strftime("%Y-%m-%d %H:%M:%S %Z")
-            except:
-                formatted_time = timestamp
-        else:
-            formatted_time = "Unknown"
-        
-        # Get weather code and description
-        weather_code = values.get("weatherCode")
-        weather_description = weather_codes.get(weather_code, "Unknown")
-        
-        # Create a readable weather report
-        weather_report = f"""
-        Current Weather for {location_name} (as of {formatted_time}):
-        ------------------------------------------------------------
-        Condition: {weather_description}
-        Temperature: {values.get('temperature', 'N/A')}°C (feels like {values.get('temperatureApparent', 'N/A')}°C)
-        Humidity: {values.get('humidity', 'N/A')}%
-        Wind: {values.get('windSpeed', 'N/A')} m/s, gusting to {values.get('windGust', 'N/A')} m/s, from {values.get('windDirection', 'N/A')}°
-        Visibility: {values.get('visibility', 'N/A')} km
-        UV Index: {values.get('uvIndex', 'N/A')}
-        Cloud Cover: {values.get('cloudCover', 'N/A')}%
-        Precipitation Probability: {values.get('precipitationProbability', 'N/A')}%
-        Rain Intensity: {values.get('rainIntensity', 'N/A')} mm/hr
-        Snow Intensity: {values.get('snowIntensity', 'N/A')} mm/hr
-        Pressure: {values.get('pressureSurfaceLevel', 'N/A')} hPa
-        """
-        
-        return weather_report.strip()
-        
-    except requests.exceptions.HTTPError as e:
-        status_code = e.response.status_code if hasattr(e, 'response') else "unknown"
-        error_detail = e.response.text if hasattr(e, 'response') else str(e)
-        
-        return f"HTTP error ({status_code}) while fetching weather data: {error_detail}"
-        
-    except Exception as e:
-        return f"Error fetching weather data: {str(e)}"
-
-
-@tool
-def extract_meeting_summary(transcript: str) -> str:
-    """Generate a comprehensive summary of a meeting transcript with key topics and next steps.
-    
-    Args:
-        transcript: The full meeting transcript or notes to analyze
-    """
-    summary_sections = {
-        "attendees": [],
-        "key_topics": [],
-        "decisions": [],
-        "action_items": []
-    }
-    
-    # Extract attendees
-    attendee_matches = re.findall(r'(?i)attendees:?\s*(.*?)(?:\n\n|\n[A-Z]|\Z)', transcript, re.DOTALL)
-    if attendee_matches:
-        attendees_text = attendee_matches[0].strip()
-        # Split by commas, 'and', or new lines
-        attendees = re.split(r',|\band\b|\n', attendees_text)
-        summary_sections["attendees"] = [a.strip() for a in attendees if a.strip()]
-    
-    # Extract key topics
-    # Look for sections like "Agenda", "Discussion", "Topics"
-    topics_pattern = r'(?i)(?:agenda|discussion|topics):?\s*(.*?)(?:\n\n|\n[A-Z]|\Z)'
-    topics_matches = re.findall(topics_pattern, transcript, re.DOTALL)
-    
-    if topics_matches:
-        topics_text = topics_matches[0]
-        # Split by numbered items or bullet points
-        topic_items = re.findall(r'(?:^|\n)(?:\d+\.|\*|\-)\s*(.*?)(?=\n(?:\d+\.|\*|\-|$)|\Z)', topics_text, re.DOTALL)
-        if topic_items:
-            summary_sections["key_topics"] = [item.strip() for item in topic_items if item.strip()]
-        else:
-            # If no bullet points, try to split by sentences or newlines
-            potential_topics = re.split(r'(?<=\.)\s+|\n+', topics_text)
-            summary_sections["key_topics"] = [t.strip() for t in potential_topics if t.strip() and len(t.strip()) > 10]
-    
-    # Extract next steps / action items with owners
-    action_pattern = r'(?i)(?:next steps|action items|follow.?up|to.?do):?\s*(.*?)(?:\n\n|\n[A-Z]|\Z)'
-    action_matches = re.findall(action_pattern, transcript, re.DOTALL)
-    
-    if action_matches:
-        actions_text = action_matches[0]
-        # Split by numbered items or bullet points
-        action_items = re.findall(r'(?:^|\n)(?:\d+\.|\*|\-)\s*(.*?)(?=\n(?:\d+\.|\*|\-|$)|\Z)', actions_text, re.DOTALL)
-        if action_items:
-            summary_sections["action_items"] = [item.strip() for item in action_items if item.strip()]
-        else:
-            # Try to split by sentences or newlines
-            potential_actions = re.split(r'(?<=\.)\s+|\n+', actions_text)
-            summary_sections["action_items"] = [a.strip() for a in potential_actions if a.strip()]
-    
-    # Look for owner assignments in action items
-    owner_pattern = r'([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)(?:\s+will|\s+to|\s+should|\s+is\s+responsible)'
-    
-    for i, action in enumerate(summary_sections["action_items"]):
-        owner_matches = re.findall(owner_pattern, action)
-        if owner_matches:
-            # If we found potential owners, highlight them
-            for owner in owner_matches:
-                # Highlight the owner's name
-                summary_sections["action_items"][i] = action.replace(
-                    owner, f"**{owner}**"
-                )
-    
-    # Extract key decisions
-    decision_pattern = r'(?i)(?:decisions?|conclusions?|outcomes?):?\s*(.*?)(?:\n\n|\n[A-Z]|\Z)'
-    decision_matches = re.findall(decision_pattern, transcript, re.DOTALL)
-    
-    if decision_matches:
-        decisions_text = decision_matches[0]
-        # Split by numbered items or bullet points
-        decision_items = re.findall(r'(?:^|\n)(?:\d+\.|\*|\-)\s*(.*?)(?=\n(?:\d+\.|\*|\-|$)|\Z)', decisions_text, re.DOTALL)
-        if decision_items:
-            summary_sections["decisions"] = [item.strip() for item in decision_items if item.strip()]
-        else:
-            # Try to split by sentences
-            potential_decisions = re.split(r'(?<=\.)\s+', decisions_text)
-            summary_sections["decisions"] = [d.strip() for d in potential_decisions if d.strip() and len(d.strip()) > 10]
-    
-    # If we still don't have key topics, try to extract them from the main text
-    if not summary_sections["key_topics"]:
-        # Look for sentences that seem to be discussing topics
-        potential_topics = re.findall(r'(?:discussed|talked about|focused on|reviewed|addressed)\s+(.*?)\.', transcript)
-        summary_sections["key_topics"] = [t.strip() for t in potential_topics if t.strip()][:5]  # Limit to 5
-    
-    # Format the final summary
-    formatted_summary = "# Meeting Summary\n\n"
-    
-    # Add attendees
-    if summary_sections["attendees"]:
-        formatted_summary += "## Attendees\n"
-        formatted_summary += ", ".join(summary_sections["attendees"]) + "\n\n"
-    
-    # Add key topics
-    if summary_sections["key_topics"]:
-        formatted_summary += "## Key Topics Discussed\n"
-        for i, topic in enumerate(summary_sections["key_topics"], 1):
-            formatted_summary += f"{i}. {topic}\n"
-        formatted_summary += "\n"
-    
-    # Add decisions
-    if summary_sections["decisions"]:
-        formatted_summary += "## Key Decisions\n"
-        for i, decision in enumerate(summary_sections["decisions"], 1):
-            formatted_summary += f"{i}. {decision}\n"
-        formatted_summary += "\n"
-    
-    # Add action items with owners
-    if summary_sections["action_items"]:
-        formatted_summary += "## Next Steps & Action Items\n"
-        for i, action in enumerate(summary_sections["action_items"], 1):
-            formatted_summary += f"{i}. {action}\n"
-        formatted_summary += "\n"
-    
-    # If we couldn't extract much, add a fallback message
-    if (not summary_sections["key_topics"] and not summary_sections["action_items"] 
-            and not summary_sections["decisions"]):
-        formatted_summary += """
-## Analysis Results
-The transcript provided does not contain clearly structured sections for topics, decisions, or action items.
-
-For better results, consider structuring your meeting notes with clear sections like:
-- Attendees: [list of people]
-- Agenda/Topics: [numbered or bulleted list]
-- Decisions: [key conclusions reached]
-- Next Steps: [actions with assigned owners]
-"""
-    
-    return formatted_summary
-
-
-@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').
-    """
-    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}"
-    except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
-
 
 final_answer = FinalAnswerTool()
 
@@ -312,13 +30,13 @@ with open("prompts.yaml", 'r') as stream:
     
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, extract_meeting_summary],  ## add your tools here (don't remove final answer)
+    tools=[final_answer, DuckDuckGoSearchTool],  ## add your tools here (don't remove final answer)
     max_steps=6,
     verbosity_level=1,
     grammar=None,
     planning_interval=None,
-    name="Meeting Summarizer",
-    description="An assistant that extracts key information from meeting transcripts, including key topics and next steps with owner assignments.",
+    name="Party planner",
+    description="Search for the best music recommendations for a party at the Wayne's mansion.",
     prompt_templates=prompt_templates
 )