Update app.py

app.py

@@ -10,112 +10,81 @@ from Gradio_UI import GradioUI
 
 
 # Below is an example of a tool that does nothing. Amaze us with your creativity !
-'''
-@tool
-
-#def fetch_movie_from_omdb(genre: str) -> dict:
-     """
-    Fetch a movie recommendation from the OMDb API based on a given genre.
 
-    Args:
-        genre (str): The movie genre to search for (e.g., "Comedy", "Drama", "Sci-Fi").
-
-    Returns:
-        dict: A dictionary containing movie details:
-            - title (str): The title of the recommended movie.
-            - year (str): The release year of the movie.
-            - genre (str): The requested genre.
-            - imdb_id (str): The IMDb ID of the movie.
-            - error (str, optional): An error message if no results are found.
-    """
-    
-    url = f"http://www.omdbapi.com/?i=tt3896198&apikey=59341a1e"
-    
-    response = requests.get(url)
-    if response.status_code != 200:
-        return {"error": "Failed to fetch movie data."}
-
-    data = response.json()
-    if "Search" not in data:
-        return {"error": "No movies found for this genre."}
-
-    best_movie = data["Search"][0]  # Pick the first result
-    return {
-        "title": best_movie["Title"],
-        "year": best_movie["Year"],
-        "genre": genre,
-        "imdb_id": best_movie["imdbID"]
-    } 
-'''
 @tool
-
-def get_movie_recommendation(mood: str, location: str, user_preferences: dict) -> dict:
-     """
-    Recommend a movie based on the user's mood, current weather at the given location,
-    and personal preferences.
-    
-    Parameters:
-    - mood (str): The user's current mood, such as "happy," "sad," "nostalgic," or "adventurous."
-    - location (str): The name of the user's location, used to fetch real-time weather data.
-    - user_preferences (dict): A dictionary containing user-specific preferences, 
-      including favorite genres and actors.
-
-    Returns:
-    - dict: A dictionary containing recommended movie details:
-      - "title" (str): The name of the recommended movie.
-      - "genre" (list): A list of genres the movie falls under.
-      - "description" (str): A brief summary of the movie.
-      - "link" (str): A link to more information about the movie.
+def get_movie_recommendation(mood: str, location: str) -> str:
+    """A tool that recommends movies based on user's mood and local weather conditions.
+    Args:
+        mood: The user's current mood (e.g., 'happy', 'sad', 'excited', 'relaxed', 'nostalgic')
+        location: The user's location to check weather (e.g., 'London', 'New York')
     """
-    
-    # Fetch weather data using DuckDuckGo search
-    search_tool = DuckDuckGoSearchTool()
-    weather_query = f"current weather in {location}"
-    weather_results = search_tool.search(weather_query)
-    
-    if not weather_results:
-        return {"error": "Could not fetch weather data."}
-    
-    weather_condition = weather_results[0].get("snippet", "").lower()
-    
-    # Define mood & weather-based genre mapping
-    genre_mapping = {
-        "happy": ["Comedy", "Romance", "Adventure"],
-        "sad": ["Drama", "Indie", "Biography"],
-        "nostalgic": ["Classic", "Drama", "Fantasy"],
-        "adventurous": ["Action", "Sci-Fi", "Thriller"],
-    }
-    
-    weather_mapping = {
-        "rain": "Drama",
-        "clear": "Adventure",
-        "clouds": "Sci-Fi",
-        "snow": "Fantasy",
-        "thunderstorm": "Thriller"
-    }
-    
-     # Determine recommended genre
-    recommended_genres = genre_mapping.get(mood, ["Drama"])
-    for key in weather_mapping:
-        if key in weather_condition:
-            recommended_genres.append(weather_mapping[key])
-    
-    # Search for a movie recommendation using DuckDuckGo
-    search_query = f"best {recommended_genres[0]} movies"
-    search_tool = DuckDuckGoSearchTool()
-    results = search_tool.search(search_query)
-    
-    if not results:
-        return {"error": "No suitable movie found."}
-    
-    best_movie = results[0]
-    return {
-        "title": best_movie.get("title", "Unknown"),
-        "genre": recommended_genres,
-        "description": best_movie.get("snippet", "No description available."),
-        "link": best_movie.get("link", "No link available")
-    }
+    try:
+        # Get weather data using wttr.in (free weather API)
+        weather_url = f"https://wttr.in/{location}?format=%C"
+        weather_response = requests.get(weather_url)
+        if weather_response.status_code != 200:
+            return f"Error: Could not fetch weather for {location}"
+        
+        weather_condition = weather_response.text.strip().lower()
+
+        # Define mood and weather based movie genre mappings
+        mood_genres = {
+            "happy": ["Comedy", "Musical", "Adventure"],
+            "sad": ["Drama", "Romance", "Independent"],
+            "excited": ["Action", "Thriller", "Sci-Fi"],
+            "relaxed": ["Documentary", "Animation", "Family"],
+            "nostalgic": ["Classic", "Drama", "Romance"]
+        }
+
+        weather_genres = {
+            "clear": ["Adventure", "Comedy", "Action"],
+            "rain": ["Drama", "Noir", "Mystery"],
+            "clouds": ["Sci-Fi", "Fantasy", "Mystery"],
+            "snow": ["Romance", "Family", "Fantasy"],
+            "thunderstorm": ["Horror", "Thriller", "Mystery"]
+        }
+
+        # Get recommended genres based on mood and weather
+        selected_genres = mood_genres.get(mood.lower(), ["Drama"])
+        for weather_key in weather_genres:
+            if weather_key in weather_condition:
+                selected_genres.extend(weather_genres[weather_key])
+                break
+
+        # Use OMDB API to fetch a movie recommendation
+        omdb_api_key = "59341a1e"  # Free tier API key
+        primary_genre = selected_genres[0]
+        movie_url = f"http://www.omdbapi.com/?apikey={omdb_api_key}&s={primary_genre}&type=movie"
+        
+        movie_response = requests.get(movie_url)
+        if movie_response.status_code != 200:
+            return f"Error: Could not fetch movie recommendation"
+
+        movie_data = movie_response.json()
+        if movie_data.get("Response") == "False":
+            return f"No movies found for your current mood and weather"
+
+        # Get first movie's details
+        first_movie = movie_data["Search"][0]
+        detail_url = f"http://www.omdbapi.com/?apikey={omdb_api_key}&i={first_movie['imdbID']}"
+        detail_response = requests.get(detail_url)
+        movie_details = detail_response.json()
+
+        # Format the recommendation response
+        recommendation = (
+            f"Based on your mood ({mood}) and the weather in {location} ({weather_condition}), "
+            f"I recommend watching:\n\n"
+            f"Title: {movie_details['Title']}\n"
+            f"Year: {movie_details['Year']}\n"
+            f"Genre: {movie_details['Genre']}\n"
+            f"Plot: {movie_details['Plot']}\n"
+            f"IMDb Rating: {movie_details['imdbRating']}"
+        )
+
+        return recommendation
 
+    except Exception as e:
+        return f"Error getting movie recommendation: {str(e)}"