Update app.py

app.py

@@ -1,311 +1,54 @@
-import gradio as gr
 import os
-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
+from huggingface_hub import hf_hub_download
+import importlib.util
+import sys
 
-# Get credentials from Hugging Face Secrets
-SEMRUSH_USER_ID = os.getenv("SEMRUSH_USER_ID")
-SEMRUSH_API_KEY = os.getenv("SEMRUSH_API_KEY")
+# Get HF token from environment (set in Space secrets)
+HF_TOKEN = os.environ.get("HF_TOKEN")
 
-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:,}"
+# Your private model/repo details
+REPO_ID = "limitedonly41/cv_all_src"
+FILENAME = "semrush_scraper_code.py"
 
-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."""
+def load_and_run():
     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']}", None
-        
-        if not overview:
-            return "📊 No domain overview data found.", None
-        
-        # 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['message'])}", 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']}", None
-        
-        if not summary:
-            return "📊 No organic summary data found.", None
-        
-        # Create chart
-        chart = create_organic_chart(summary)
-        
-        # 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])
-        
-        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['message'])}", 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']}"
-        
-        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"
+        # Download the code file from private repo
+        file_path = hf_hub_download(
+            repo_id=REPO_ID,
+            filename=FILENAME,
+            token=HF_TOKEN,
+            repo_type="model"
+        )
         
-        # 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"
+        # Load the module dynamically
+        spec = importlib.util.spec_from_file_location("semrush_scraper_module", file_path)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules["semrush_scraper_module"] = module
+        spec.loader.exec_module(module)
+        
+        # Try to find and launch the interface
+        if hasattr(module, 'interface'):
+            print("Found 'interface' object, launching...")
+            module.interface.launch()
+        elif hasattr(module, 'demo'):
+            print("Found 'demo' object, launching...")
+            module.demo.launch()
+        elif hasattr(module, 'create_interface'):
+            print("Found 'create_interface' function, creating and launching...")
+            interface = module.create_interface()
+            interface.launch()
         else:
-            health_status = "🔴 Unhealthy"
-        
-        result = f"""🔗 **BACKLINKS PROFILE SUMMARY**
-
-🏆 **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
-    
+            print("Error: Could not find 'interface', 'demo', or 'create_interface' in the loaded module")
+            print("Available attributes:", dir(module))
+            
     except Exception as e:
-        return f"❌ Error: {str(e['message'])}", None
-
-# 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", 
-            placeholder="example.com or https://example.com",
-            value="",
-            scale=3
-        )
-        analyze_btn = gr.Button("🚀 Analyze Domain", variant="primary", scale=1)
-    
-    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
-            )
-    
-    # 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=analyze_domain,
-        inputs=domain_input,
-        outputs=[overview_output, overview_chart, organic_output, organic_chart, backlinks_output]
-    )
-    
-    # Add examples
-    gr.Examples(
-        examples=[
-            ["google.com"],
-            ["github.com"],
-            ["stackoverflow.com"],
-            ["wikipedia.org"]
-        ],
-        inputs=domain_input
-    )
+        print(f"Error loading code: {e}")
+        import traceback
+        traceback.print_exc()
+        print("\nMake sure:")
+        print("1. HF_TOKEN is set in Space secrets")
+        print("2. REPO_ID points to your private repository")
+        print("3. The code file exists in the repository")
 
 if __name__ == "__main__":
-    demo.launch()
+    load_and_run()