Reverted to NewGameRecommender Code

app.py

@@ -4,10 +4,6 @@ from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
 import gradio as gr
 import numpy as np
-import re
-from PIL import Image
-from io import BytesIO
-import requests
 
 # Load the data - when deploying, adjust the path to where your dataset will be stored
 def load_data():
@@ -60,32 +56,7 @@ def get_recommendations(game_name, data, feature_vectors):
         
         # Get additional information
         about = data.loc[index, 'about_the_game'] if 'about_the_game' in data.columns else "No description available"
-        
-        # Try to get an image - first check screenshots, then header_image
-        image_url = None
-        if 'screenshots' in data.columns and pd.notna(data.loc[index, 'screenshots']):
-            # Try to extract the first screenshot URL
-            screenshots = data.loc[index, 'screenshots']
-            if isinstance(screenshots, str):
-                # Handle potential JSON format
-                if screenshots.startswith('[') and ']' in screenshots:
-                    try:
-                        import json
-                        screenshot_list = json.loads(screenshots)
-                        if screenshot_list and isinstance(screenshot_list, list) and len(screenshot_list) > 0:
-                            if isinstance(screenshot_list[0], dict) and 'path_full' in screenshot_list[0]:
-                                image_url = screenshot_list[0]['path_full']
-                            elif isinstance(screenshot_list[0], str):
-                                image_url = screenshot_list[0]
-                    except:
-                        # If JSON parsing fails, try regex
-                        url_match = re.search(r'https?://[^\s,\'"]+\.(jpg|jpeg|png|gif)', screenshots)
-                        if url_match:
-                            image_url = url_match.group(0)
-        
-        # If no screenshot, try header image
-        if (image_url is None or image_url == '') and 'header_image' in data.columns:
-            image_url = data.loc[index, 'header_image'] if pd.notna(data.loc[index, 'header_image']) else None
+        image_url = data.loc[index, 'header_image'] if 'header_image' in data.columns else None
         
         # Get platform information
         platforms = []
@@ -97,59 +68,23 @@ def get_recommendations(game_name, data, feature_vectors):
             platforms.append("Linux")
         platforms_str = ", ".join(platforms) if platforms else "Unknown"
         
-        # Get price information
-        price = data.loc[index, 'price'] if 'price' in data.columns else None
-        price_str = f"${price}" if pd.notna(price) and price != '' else "Price not available"
-        
         # Format the result
-        result = f"**{name}**\n\n"
-        result += f"**Price:** {price_str}\n"
+        result = f"**{i}. {name}**\n\n"
         result += f"**Platforms:** {platforms_str}\n\n"
         
-        # Add genres if available
-        if 'genres' in data.columns and pd.notna(data.loc[index, 'genres']):
-            genres = data.loc[index, 'genres']
-            if genres and genres != '':
-                # Clean up genres format
-                if isinstance(genres, str):
-                    # Handle potential JSON format
-                    if genres.startswith('[') and ']' in genres:
-                        try:
-                            import json
-                            genres_list = json.loads(genres)
-                            if isinstance(genres_list, list):
-                                genres = ", ".join(genres_list)
-                        except:
-                            pass
-                    result += f"**Genres:** {genres}\n\n"
-        
-        # Truncate and clean the about text
+        # Truncate the about text to keep output clean
         if about and about != "":
-            # Remove HTML tags
-            about_clean = re.sub(r'<.*?>', '', about)
-            about_truncated = about_clean[:300] + "..." if len(about_clean) > 300 else about_clean
-            result += f"**About the Game:** {about_truncated}\n"
+            about_truncated = about[:300] + "..." if len(about) > 300 else about
+            result += f"**About the Game:** {about_truncated}\n\n"
         else:
-            result += "**About the Game:** No description available\n"
+            result += "**About the Game:** No description available\n\n"
+        
+        result += "---\n\n"
         
         results.append((result, image_url))
     
     return results
 
-# Function to safely load image from URL
-def load_image_safely(url):
-    if not url or str(url).lower() == 'nan':
-        return None
-        
-    try:
-        response = requests.get(url, timeout=5)
-        if response.status_code == 200:
-            return Image.open(BytesIO(response.content))
-        else:
-            return None
-    except:
-        return None
-
 # Gradio interface function
 def recommend_games(game_name):
     data = load_data()
@@ -168,99 +103,45 @@ def recommend_games(game_name):
     
     for result, image_url in recommendations:
         result_texts.append(result)
-        # Add similarity score if available
         if image_url and str(image_url) != 'nan':
-            # For Hugging Face Spaces, use the URL directly
-            # The image loading will happen through the browser
             result_images.append(image_url)
         else:
             # Use a placeholder image if no image URL is available
             result_images.append(None)
     
-    # Return list of recommendations with their info
-    return result_texts, result_images
-
-# Create the Gradio interface with individual game cards
-def create_recommendation_ui(game_name):
-    data = load_data()
-    if data is None:
-        return [gr.Markdown("Failed to load data. Please check the data file.")]
-    
-    feature_vectors = prepare_features(data)
-    recommendations = get_recommendations(game_name, data, feature_vectors)
-    
-    if isinstance(recommendations, str):
-        return [gr.Markdown(recommendations)]
-    
-    result_texts, result_images = recommendations
-    
-    # Create output components dynamically
-    output_components = []
+    # Create a gallery of results
+    results_html = ""
+    for i, (text, img) in enumerate(zip(result_texts, result_images)):
+        results_html += text
     
-    for i, (text, img_url) in enumerate(zip(result_texts, result_images)):
-        with gr.Group():
-            with gr.Row():
-                with gr.Column(scale=1):
-                    if img_url and str(img_url) != 'nan':
-                        output_components.append(gr.Image(value=img_url, label=f"Game {i+1}"))
-                    else:
-                        output_components.append(gr.Markdown("*No image available*"))
-                with gr.Column(scale=2):
-                    output_components.append(gr.Markdown(text))
-            output_components.append(gr.Markdown("---"))
-    
-    return output_components
+    return results_html, result_images
 
+# Create the Gradio interface
 with gr.Blocks(title="Steam Game Recommender") as demo:
     gr.Markdown("# Steam Game Recommender")
     gr.Markdown("Enter your favorite game to get recommendations for similar games.")
     
     with gr.Row():
-        input_text = gr.Textbox(label="Enter your favorite game:", placeholder="e.g., Half-Life 2")
-        submit_btn = gr.Button("Get Recommendations", variant="primary")
+        input_text = gr.Textbox(label="Enter your favorite game:")
+        submit_btn = gr.Button("Get Recommendations")
     
-    output_container = gr.Group(visible=False)
-    with output_container:
-        gr.Markdown("## Your Recommendations")
-        recommendation_outputs = []
-        for i in range(9):  # For 9 recommendations
-            with gr.Group():
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        recommendation_outputs.append(gr.Image(label=f"Game {i+1}"))
-                    with gr.Column(scale=2):
-                        recommendation_outputs.append(gr.Markdown())
-                recommendation_outputs.append(gr.Markdown("---"))
+    with gr.Row():
+        output_text = gr.Markdown(label="Recommendations")
     
-    def process_recommendations(game_name):
-        data = load_data()
-        if data is None:
-            return [gr.update(visible=True), gr.update(value="Failed to load data. Please check the data file.")]
-        
-        feature_vectors = prepare_features(data)
-        recommendations = get_recommendations(game_name, data, feature_vectors)
-        
-        if isinstance(recommendations, str):
-            return [gr.update(visible=True), gr.update(value=recommendations)]
-        
-        result_texts, result_images = recommendations
-        updates = [gr.update(visible=True)]
-        
-        for i, (text, img_url) in enumerate(zip(result_texts, result_images)):
-            updates.append(gr.update(value=img_url if img_url and str(img_url) != 'nan' else None))
-            updates.append(gr.update(value=text))
-            updates.append(gr.update())
-            
-        # Fill any remaining slots with empty updates
-        while len(updates) < len(recommendation_outputs) + 1:
-            updates.append(gr.update(visible=False))
-            
-        return updates
+    with gr.Row():
+        output_gallery = gr.Gallery(
+            label="Game Images", 
+            show_label=True, 
+            elem_id="gallery",
+            columns=[3], 
+            rows=[3], 
+            height="auto"
+        )
     
     submit_btn.click(
-        fn=process_recommendations,
+        fn=recommend_games,
         inputs=input_text,
-        outputs=[output_container] + recommendation_outputs
+        outputs=[output_text, output_gallery]
     )
 
 # Launch the app