Update app.py

app.py

@@ -1,123 +1,308 @@
 import gradio as gr
 import os
-from parser import SemRush
 import json
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+from datetime import datetime
+from parser import SemRush
 
 # Get credentials from Hugging Face Secrets
 SEMRUSH_USER_ID = os.getenv("SEMRUSH_USER_ID")
 SEMRUSH_API_KEY = os.getenv("SEMRUSH_API_KEY")
 
+def format_number(num):
+    """Format large numbers with commas and abbreviations."""
+    if num >= 1000000000:
+        return f"{num/1000000000:.1f}B"
+    elif num >= 1000000:
+        return f"{num/1000000:.1f}M"
+    elif num >= 1000:
+        return f"{num/1000:.1f}K"
+    else:
+        return f"{num:,}"
+
+def create_traffic_chart(data):
+    """Create a line chart for organic traffic over time."""
+    if not data or "error" in data:
+        return None
+    
+    dates = []
+    traffic = []
+    
+    for date_str, traffic_val in data.items():
+        # Parse date
+        try:
+            date_obj = datetime.strptime(date_str, "%Y%m%d")
+            dates.append(date_obj)
+            traffic.append(traffic_val)
+        except:
+            continue
+    
+    if not dates:
+        return None
+    
+    df = pd.DataFrame({'Date': dates, 'Traffic': traffic})
+    df = df.sort_values('Date')
+    
+    fig = px.line(df, x='Date', y='Traffic', 
+                  title='Organic Traffic Trend Over Time',
+                  labels={'Traffic': 'Organic Traffic', 'Date': 'Date'})
+    
+    fig.update_traces(line=dict(color='#1f77b4', width=3))
+    fig.update_layout(
+        xaxis_title="Date",
+        yaxis_title="Organic Traffic",
+        hovermode='x unified',
+        template="plotly_white"
+    )
+    
+    return fig
+
+def create_organic_chart(data):
+    """Create a bar chart for top organic traffic by country."""
+    if not data or "error" in data:
+        return None
+    
+    # Filter and sort data
+    filtered_data = {k: v for k, v in data.items() if v > 0}
+    sorted_data = dict(sorted(filtered_data.items(), key=lambda x: x[1], reverse=True)[:15])
+    
+    if not sorted_data:
+        return None
+    
+    countries = list(sorted_data.keys())
+    traffic = list(sorted_data.values())
+    
+    fig = px.bar(x=traffic, y=countries, orientation='h',
+                 title='Top 15 Countries by Organic Traffic',
+                 labels={'x': 'Organic Traffic', 'y': 'Country/Database'})
+    
+    fig.update_layout(
+        yaxis={'categoryorder': 'total ascending'},
+        template="plotly_white",
+        height=500
+    )
+    
+    return fig
+
 def get_domain_overview(domain):
     """Get domain overview data from SemRush."""
     try:
+        if not SEMRUSH_USER_ID or not SEMRUSH_API_KEY:
+            return "❌ API credentials not found. Please set SEMRUSH_USER_ID and SEMRUSH_API_KEY in Secrets.", None
+        
         semrush = SemRush(SEMRUSH_USER_ID, SEMRUSH_API_KEY, domain)
         overview = semrush.domainOverview()
         
         if "error" in overview:
-            return f"Error: {overview['error']}"
+            return f"❌ Error: {overview['error']}", None
         
-        # Format the data for display
-        formatted_data = []
-        for date, traffic in overview.items():
-            formatted_data.append(f"Date: {date}, Organic Traffic: {traffic}")
+        if not overview:
+            return "📊 No domain overview data found.", None
         
-        return "\n".join(formatted_data) if formatted_data else "No data found"
+        # Create chart
+        chart = create_traffic_chart(overview)
+        
+        # Format text summary
+        formatted_lines = []
+        sorted_overview = dict(sorted(overview.items()))
+        
+        for date_str, traffic in sorted_overview.items():
+            try:
+                date_obj = datetime.strptime(date_str, "%Y%m%d")
+                formatted_date = date_obj.strftime("%B %Y")
+                formatted_traffic = format_number(traffic)
+                formatted_lines.append(f"📅 **{formatted_date}**: {formatted_traffic} visitors")
+            except:
+                formatted_lines.append(f"📅 **{date_str}**: {format_number(traffic)} visitors")
+        
+        result = "📈 **ORGANIC TRAFFIC TREND**\n\n" + "\n".join(formatted_lines)
+        
+        return result, chart
     
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"❌ Error: {str(e)}", None
 
 def get_organic_summary(domain):
     """Get organic summary data from SemRush."""
     try:
+        if not SEMRUSH_USER_ID or not SEMRUSH_API_KEY:
+            return "❌ API credentials not found. Please set SEMRUSH_USER_ID and SEMRUSH_API_KEY in Secrets.", None
+        
         semrush = SemRush(SEMRUSH_USER_ID, SEMRUSH_API_KEY, domain)
         summary = semrush.organicSummary()
         
         if "error" in summary:
-            return f"Error: {summary['error']}"
+            return f"❌ Error: {summary['error']}", None
+        
+        if not summary:
+            return "📊 No organic summary data found.", None
+        
+        # Create chart
+        chart = create_organic_chart(summary)
         
-        # Format the data for display
-        formatted_data = []
-        for database, traffic in summary.items():
-            formatted_data.append(f"Database: {database}, Organic Traffic: {traffic}")
+        # Format text summary - show top 20 countries
+        filtered_summary = {k: v for k, v in summary.items() if v > 0}
+        sorted_summary = dict(sorted(filtered_summary.items(), key=lambda x: x[1], reverse=True)[:20])
         
-        return "\n".join(formatted_data) if formatted_data else "No data found"
+        total_traffic = sum(sorted_summary.values())
+        
+        formatted_lines = [f"🌍 **TOTAL ORGANIC TRAFFIC**: {format_number(total_traffic)} visitors\n"]
+        
+        for i, (database, traffic) in enumerate(sorted_summary.items(), 1):
+            percentage = (traffic / total_traffic) * 100 if total_traffic > 0 else 0
+            flag_emoji = "🏆" if i <= 3 else "🌐"
+            formatted_lines.append(f"{flag_emoji} **{database.upper()}**: {format_number(traffic)} ({percentage:.1f}%)")
+        
+        result = "\n".join(formatted_lines)
+        
+        return result, chart
     
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"❌ Error: {str(e)}", None
 
 def get_backlinks_summary(domain):
     """Get backlinks summary data from SemRush."""
     try:
+        if not SEMRUSH_USER_ID or not SEMRUSH_API_KEY:
+            return "❌ API credentials not found. Please set SEMRUSH_USER_ID and SEMRUSH_API_KEY in Secrets."
+        
         semrush = SemRush(SEMRUSH_USER_ID, SEMRUSH_API_KEY, domain)
         backlinks = semrush.backlinksSummary()
         
         if "error" in backlinks:
-            return f"Error: {backlinks['error']}"
+            return f"❌ Error: {backlinks['error']}"
         
-        # Format the data for display
-        return json.dumps(backlinks, indent=2)
-    
-    except Exception as e:
-        return f"Error: {str(e)}"
+        if not backlinks:
+            return "📊 No backlinks data found."
+        
+        # Format backlinks data nicely
+        authority_score = backlinks.get('authorityScore', 0)
+        total_backlinks = backlinks.get('backlinks', 0)
+        health_score = backlinks.get('health', 0)
+        link_power = backlinks.get('linkPower', 0)
+        naturalness = backlinks.get('naturalness', 0)
+        referring_domains = backlinks.get('referringDomains', 0)
+        search_traffic = backlinks.get('searchTraffic', 0)
+        
+        # Authority score interpretation
+        if authority_score >= 80:
+            authority_status = "🟢 Excellent"
+        elif authority_score >= 60:
+            authority_status = "🟡 Good"
+        elif authority_score >= 40:
+            authority_status = "🟠 Average"
+        else:
+            authority_status = "🔴 Poor"
+        
+        # Health score interpretation
+        if health_score >= 80:
+            health_status = "🟢 Healthy"
+        elif health_score >= 60:
+            health_status = "🟡 Moderate"
+        elif health_score >= 40:
+            health_status = "🟠 Needs Attention"
+        else:
+            health_status = "🔴 Unhealthy"
+        
+        result = f"""🔗 **BACKLINKS PROFILE SUMMARY**
 
-def get_all_data(domain):
-    """Get all available data for a domain."""
-    if not domain:
-        return "Please enter a domain name"
-    
-    results = {}
-    
-    # Clean domain (remove protocol if present)
-    clean_domain = domain.replace('https://', '').replace('http://', '').strip('/')
-    
-    # Get all data types
-    results["Domain Overview"] = get_domain_overview(clean_domain)
-    results["Organic Summary"] = get_organic_summary(clean_domain)
-    results["Backlinks Summary"] = get_backlinks_summary(clean_domain)
-    
-    # Format output
-    output = f"# SemRush Data for: {clean_domain}\n\n"
-    
-    for section, data in results.items():
-        output += f"## {section}\n{data}\n\n"
+🏆 **Authority Score**: {authority_score}/100 ({authority_status})
+📊 **Health Score**: {health_score}/100 ({health_status})
+
+📈 **KEY METRICS**:
+• **Total Backlinks**: {format_number(total_backlinks)}
+• **Referring Domains**: {format_number(referring_domains)}
+• **Link Power**: {link_power}/10
+• **Naturalness**: {naturalness}/10
+• **Search Traffic**: {search_traffic}%
+
+💡 **INSIGHTS**:
+• Average of {total_backlinks/referring_domains:.1f} links per referring domain
+• {"Strong" if link_power >= 5 else "Moderate" if link_power >= 3 else "Weak"} link profile strength
+• {"Natural" if naturalness >= 7 else "Moderately natural" if naturalness >= 5 else "Potentially artificial"} link pattern"""
+        
+        return result
     
-    return output
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
-# Create Gradio interface
-with gr.Blocks(title="SemRush Domain Analyzer") as demo:
-    gr.Markdown("# SemRush Domain Analyzer")
-    gr.Markdown("Enter a domain name to get SEO data from SemRush API")
+# Create Gradio interface with tabs
+with gr.Blocks(title="SemRush Domain Analyzer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🔍 SemRush Domain Analyzer")
+    gr.Markdown("**Comprehensive SEO analysis powered by SemRush API**")
     
     with gr.Row():
         domain_input = gr.Textbox(
-            label="Domain Name", 
+            label="🌐 Domain Name", 
             placeholder="example.com or https://example.com",
-            value=""
+            value="",
+            scale=3
         )
+        analyze_btn = gr.Button("🚀 Analyze Domain", variant="primary", scale=1)
     
-    with gr.Row():
-        analyze_btn = gr.Button("Analyze Domain", variant="primary")
+    with gr.Tabs():
+        with gr.Tab("📈 Traffic Overview"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    overview_output = gr.Markdown(
+                        value="Enter a domain and click 'Analyze Domain' to see traffic trends.",
+                        line_breaks=True
+                    )
+                with gr.Column(scale=1):
+                    overview_chart = gr.Plot(label="Traffic Trend Chart")
+        
+        with gr.Tab("🌍 Geographic Distribution"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    organic_output = gr.Markdown(
+                        value="Geographic breakdown of organic traffic will appear here.",
+                        line_breaks=True
+                    )
+                with gr.Column(scale=1):
+                    organic_chart = gr.Plot(label="Top Countries Chart")
+        
+        with gr.Tab("🔗 Backlinks Profile"):
+            backlinks_output = gr.Markdown(
+                value="Comprehensive backlinks analysis will appear here.",
+                line_breaks=True
+            )
     
-    with gr.Row():
-        output = gr.Textbox(
-            label="Results", 
-            lines=20, 
-            max_lines=50,
-            show_copy_button=True
-        )
+    # Event handlers
+    def analyze_domain(domain):
+        if not domain:
+            return (
+                "⚠️ Please enter a domain name",
+                None,
+                "⚠️ Please enter a domain name", 
+                None,
+                "⚠️ Please enter a domain name"
+            )
+        
+        # Clean domain
+        clean_domain = domain.replace('https://', '').replace('http://', '').strip('/')
+        
+        # Get all data
+        overview_text, overview_fig = get_domain_overview(clean_domain)
+        organic_text, organic_fig = get_organic_summary(clean_domain)
+        backlinks_text = get_backlinks_summary(clean_domain)
+        
+        return overview_text, overview_fig, organic_text, organic_fig, backlinks_text
     
     analyze_btn.click(
-        fn=get_all_data,
+        fn=analyze_domain,
         inputs=domain_input,
-        outputs=output
+        outputs=[overview_output, overview_chart, organic_output, organic_chart, backlinks_output]
     )
     
     # Add examples
     gr.Examples(
         examples=[
-            ["example.com"],
-            ["google.com"], 
-            ["github.com"]
+            ["google.com"],
+            ["github.com"],
+            ["stackoverflow.com"],
+            ["wikipedia.org"]
         ],
         inputs=domain_input
     )