Update app.py

app.py

@@ -1,42 +1,288 @@
 import gradio as gr
-from pytrends.request import TrendReq
-import matplotlib.pyplot as plt
-import os
-
-def get_trends(keyword):
-    # Initialize the pytrends object
-    pytrends = TrendReq(hl="en-US", tz=360)
-    
-    # Build the payload and fetch the trends data
-    pytrends.build_payload(kw_list=[keyword])
-    df = pytrends.interest_over_time()
-    
-    # If there is no data, return a message
-    if df.empty:
-        return "No data available for this keyword. Please try a different one."
-    
-    # Create a plot
-    plt.figure(figsize=(20, 10))
-    df[keyword].plot()
-    plt.title(f"Google Trends for '{keyword}'", fontsize=20)
-    plt.xlabel("Date", fontsize=16)
-    plt.ylabel("Interest over time", fontsize=16)
-    plt.grid(True)
-    
-    # Save the plot to a temporary file
-    plot_file = "/tmp/trends_plot.png"
-    plt.savefig(plot_file)
-    plt.close()  # Close the plot to avoid display issues
-    
-    return plot_file  # Return the file path for Gradio to display the image
-
-# Set up the Gradio interface
+import requests
+import json
+import pandas as pd
+import time
+from datetime import datetime
+from collections import Counter
+import numpy as np
+from typing import List, Dict, Any
+import logging
+import sys
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+class AmazonSuggestionExpander:
+    def __init__(self):
+        self.headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        self.cache = {}
+        self.last_request_time = 0
+        self.request_delay = 1.0  # Minimum delay between requests
+
+    def _rate_limit(self):
+        """Implement rate limiting between requests"""
+        current_time = time.time()
+        time_since_last_request = current_time - self.last_request_time
+        if time_since_last_request < self.request_delay:
+            time.sleep(self.request_delay - time_since_last_request)
+        self.last_request_time = time.time()
+
+    def _fetch_suggestions(self, keyword: str, max_retries: int = 3) -> List[str]:
+        """Fetch suggestions from Amazon with retry logic and caching"""
+        if keyword in self.cache:
+            return self.cache[keyword]
+
+        for attempt in range(max_retries):
+            try:
+                self._rate_limit()
+                url = f"https://completion.amazon.com/api/2017/suggestions?mid=ATVPDKIKX0DER&alias=aps&prefix={keyword}"
+                response = requests.get(url, headers=self.headers, timeout=10)
+                
+                if response.status_code == 429:  # Too Many Requests
+                    logging.warning(f"Rate limited on attempt {attempt + 1}")
+                    time.sleep(30 * (attempt + 1))  # Exponential backoff
+                    continue
+                    
+                data = json.loads(response.text)
+                suggestions = [suggestion['value'] for suggestion in data.get('suggestions', [])]
+                self.cache[keyword] = suggestions
+                return suggestions
+
+            except requests.exceptions.RequestException as e:
+                logging.error(f"Request error on attempt {attempt + 1}: {str(e)}")
+                if attempt == max_retries - 1:
+                    raise e
+                time.sleep(5 * (attempt + 1))  # Exponential backoff
+            except json.JSONDecodeError as e:
+                logging.error(f"JSON decode error on attempt {attempt + 1}: {str(e)}")
+                if attempt == max_retries - 1:
+                    raise e
+                time.sleep(5 * (attempt + 1))
+
+        return []
+
+    def get_amazon_suggestions(self, keyword: str, progress: gr.Progress = None) -> List[str]:
+        """Get expanded suggestions with progress tracking"""
+        try:
+            suggestions = []
+            if progress:
+                progress(0, desc="Getting initial suggestions...")
+            
+            # Get suggestions for the main keyword
+            main_suggestions = self._fetch_suggestions(keyword)
+            suggestions.extend(main_suggestions)
+            
+            # Get suggestions for each letter of the alphabet
+            alpha = 'abcdefghijklmnopqrstuvwxyz'
+            for i, letter in enumerate(alpha):
+                if progress:
+                    progress((i + 1) / len(alpha), desc=f"Processing '{keyword} {letter}'...")
+                extended_suggestions = self._fetch_suggestions(f"{keyword} {letter}")
+                suggestions.extend(extended_suggestions)
+            
+            # Remove duplicates and sort
+            suggestions = list(set(suggestions))
+            suggestions.sort()
+            
+            return suggestions
+
+        except Exception as e:
+            logging.error(f"Error in get_amazon_suggestions: {str(e)}")
+            return [f"Error: {str(e)}"]
+
+class KeywordAnalyzer:
+    @staticmethod
+    def analyze_suggestions(suggestions: List[str]) -> Dict[str, Any]:
+        """Analyze suggestions and return detailed metrics"""
+        df = pd.DataFrame(suggestions, columns=['Suggestions'])
+        
+        # Word count analysis
+        df['word_count'] = df['Suggestions'].str.split().str.len()
+        
+        # Create word frequency analysis
+        all_words = ' '.join(suggestions).lower().split()
+        word_freq = Counter(all_words)
+        
+        # Price analysis (if present)
+        price_pattern = r'\$\d+\.?\d*'
+        df['has_price'] = df['Suggestions'].str.contains(price_pattern)
+        
+        # Brand mention analysis
+        # This is a simple example - you might want to maintain a proper brand list
+        df['has_brand'] = df['Suggestions'].apply(lambda x: any(brand in x.lower() for brand in ['amazon', 'prime']))
+        
+        analysis = {
+            'total_count': len(suggestions),
+            'avg_word_count': df['word_count'].mean(),
+            'max_word_count': df['word_count'].max(),
+            'min_word_count': df['word_count'].min(),
+            'word_count_distribution': df['word_count'].value_counts().to_dict(),
+            'common_words': {word: count for word, count in word_freq.most_common(10)},
+            'price_mentions': df['has_price'].sum(),
+            'brand_mentions': df['has_brand'].sum(),
+            'length_stats': {
+                'avg_length': df['Suggestions'].str.len().mean(),
+                'max_length': df['Suggestions'].str.len().max(),
+                'min_length': df['Suggestions'].str.len().min()
+            }
+        }
+        
+        return analysis
+
+def format_analysis_output(analysis: Dict[str, Any]) -> str:
+    """Format analysis results into readable text"""
+    output = "\n=== Analysis Results ===\n\n"
+    
+    output += f"Total Suggestions: {analysis['total_count']}\n"
+    output += f"Word Count Stats:\n"
+    output += f"- Average: {analysis['avg_word_count']:.1f} words\n"
+    output += f"- Maximum: {analysis['max_word_count']} words\n"
+    output += f"- Minimum: {analysis['min_word_count']} words\n\n"
+    
+    output += "Most Common Words:\n"
+    for word, count in analysis['common_words'].items():
+        output += f"- {word}: {count} times\n"
+    
+    output += f"\nPrice Mentions: {analysis['price_mentions']}\n"
+    output += f"Brand Mentions: {analysis['brand_mentions']}\n"
+    
+    output += f"\nCharacter Length Stats:\n"
+    output += f"- Average: {analysis['length_stats']['avg_length']:.1f} characters\n"
+    output += f"- Maximum: {analysis['length_stats']['max_length']} characters\n"
+    output += f"- Minimum: {analysis['length_stats']['min_length']} characters\n"
+    
+    return output
+
+def create_visualization(analysis: Dict[str, Any]) -> str:
+    """Create HTML visualization of the analysis"""
+    html = """
+    <style>
+        .analysis-container {
+            font-family: Arial, sans-serif;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        .metric-card {
+            background: #f5f5f5;
+            border-radius: 8px;
+            padding: 15px;
+            margin: 10px 0;
+        }
+        .word-cloud {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            margin: 10px 0;
+        }
+        .word-item {
+            background: #e0e0e0;
+            padding: 5px 10px;
+            border-radius: 15px;
+            font-size: 14px;
+        }
+    </style>
+    <div class="analysis-container">
+        <div class="metric-card">
+            <h3>Overall Statistics</h3>
+            <p>Total Suggestions: {}</p>
+            <p>Average Words: {:.1f}</p>
+        </div>
+        <div class="metric-card">
+            <h3>Most Common Words</h3>
+            <div class="word-cloud">
+    """.format(
+        analysis['total_count'],
+        analysis['avg_word_count']
+    )
+    
+    for word, count in analysis['common_words'].items():
+        html += f'<span class="word-item">{word} ({count})</span>'
+    
+    html += """
+            </div>
+        </div>
+    </div>
+    """
+    return html
+
+def search_and_display(keyword: str, min_length: int = 0, progress: gr.Progress = gr.Progress()) -> tuple:
+    """Main function to handle the search and display process"""
+    if not keyword:
+        return "Please enter a keyword", None, None
+    
+    try:
+        # Initialize expander and get suggestions
+        expander = AmazonSuggestionExpander()
+        suggestions = expander.get_amazon_suggestions(keyword, progress)
+        
+        # Filter suggestions by minimum length if specified
+        if min_length > 0:
+            suggestions = [s for s in suggestions if len(s.split()) >= min_length]
+        
+        # Analyze suggestions
+        analyzer = KeywordAnalyzer()
+        analysis = analyzer.analyze_suggestions(suggestions)
+        
+        # Create DataFrame and save to CSV
+        df = pd.DataFrame(suggestions, columns=['Suggestions'])
+        df['Word Count'] = df['Suggestions'].str.split().str.len()
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        csv_filename = f"amazon_suggestions_{timestamp}.csv"
+        df.to_csv(csv_filename, index=False)
+        
+        # Create output text
+        output_text = f"Found {len(suggestions)} suggestions for '{keyword}':\n\n"
+        for i, suggestion in enumerate(suggestions, 1):
+            output_text += f"{i}. {suggestion}\n"
+        
+        # Add analysis results
+        output_text += "\n" + format_analysis_output(analysis)
+        
+        # Create visualization
+        visualization = create_visualization(analysis)
+        
+        return output_text, csv_filename, visualization
+        
+    except Exception as e:
+        logging.error(f"Error in search_and_display: {str(e)}")
+        return f"Error occurred: {str(e)}", None, None
+
+# Create Gradio interface
 iface = gr.Interface(
-    fn=get_trends,
-    inputs=gr.Textbox(lines=1, label="Enter a keyword"),
-    outputs=gr.Image(type="file"),  # Output is now an image file
-    title="Google Trends Visualizer",
-    description="Enter a keyword to see its Google Trends data over time."
+    fn=search_and_display,
+    inputs=[
+        gr.Textbox(label="Enter keyword", placeholder="Type your keyword here..."),
+        gr.Slider(minimum=0, maximum=10, step=1, label="Minimum word count filter", value=0)
+    ],
+    outputs=[
+        gr.Textbox(label="Results", lines=20),
+        gr.File(label="Download CSV"),
+        gr.HTML(label="Visualization")
+    ],
+    title="Advanced Amazon Suggestion Expander",
+    description="""
+    Get expanded keyword suggestions from Amazon's search autocomplete with detailed analysis.
+    Enter a keyword to see all related suggestions, analytics, and visualizations.
+    """,
+    examples=[
+        ["coffee maker", 2],
+        ["gaming laptop", 3],
+        ["yoga mat", 1]
+    ],
+    cache_examples=True,
+    theme=gr.themes.Soft()
 )
 
-iface.launch()
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()