Update app.py

app.py

@@ -1,376 +1,120 @@
 import gradio as gr
 import google.generativeai as genai
-import textstat
-import re
-import requests
-from urllib.parse import urlparse
+import os
 
-# --- Sanitize for f-string ---
-def sanitize_for_fstring(text):
-    return text.replace('{', '{{').replace('}', '}}')
-
-# --- Semantic SEO Enhancement ---
-def generate_semantic_keywords(keyword):
-    """Generate semantic variations of the primary keyword"""
-    words = keyword.lower().split()
-    variations = []
-    
-    # Add common semantic variations
-    semantic_map = {
-        'benefits': ['advantages', 'pros', 'positive effects', 'value', 'perks'],
-        'tips': ['advice', 'strategies', 'recommendations', 'guidelines', 'hacks'],
-        'guide': ['tutorial', 'handbook', 'instructions', 'walkthrough', 'manual'],
-        'best': ['top', 'excellent', 'outstanding', 'premier', 'finest'],
-        'how to': ['ways to', 'methods to', 'steps to', 'process of'],
-        'review': ['analysis', 'evaluation', 'assessment', 'examination'],
-        'comparison': ['versus', 'difference', 'contrast', 'alternative']
-    }
-    
-    for word in words:
-        if word in semantic_map:
-            variations.extend(semantic_map[word])
-    
-    # Add plurals and singulars
-    for word in words:
-        if word.endswith('s') and len(word) > 3:
-            variations.append(word[:-1])  # Remove 's' for singular
-        elif not word.endswith('s'):
-            variations.append(word + 's')  # Add 's' for plural
-    
-    return list(set(variations))
-
-# --- Enhanced Readability Analysis ---
-def analyze_text_advanced(text, keyword):
-    """Enhanced readability analysis with interpretation"""
-    flesch_score = textstat.flesch_reading_ease(text)
-    gunning_fog = textstat.gunning_fog(text)
-    word_count = len(text.split())
-    sentence_count = textstat.sentence_count(text)
-    avg_sentence_length = word_count / sentence_count if sentence_count > 0 else 0
-    
-    # Keyword analysis
-    keyword_count = text.lower().count(keyword.lower())
-    density = round((keyword_count / word_count) * 100, 2) if word_count > 0 else 0
-    
-    # Readability interpretation
-    if flesch_score >= 90:
-        readability_level = "Very Easy (5th grade)"
-    elif flesch_score >= 80:
-        readability_level = "Easy (6th grade)"
-    elif flesch_score >= 70:
-        readability_level = "Fairly Easy (7th grade)"
-    elif flesch_score >= 60:
-        readability_level = "Standard (8th-9th grade)"
-    elif flesch_score >= 50:
-        readability_level = "Fairly Difficult (10th-12th grade)"
-    elif flesch_score >= 30:
-        readability_level = "Difficult (College level)"
-    else:
-        readability_level = "Very Difficult (Graduate level)"
-    
-    return {
-        'flesch_score': flesch_score,
-        'gunning_fog': gunning_fog,
-        'readability_level': readability_level,
-        'word_count': word_count,
-        'sentence_count': sentence_count,
-        'avg_sentence_length': round(avg_sentence_length, 1),
-        'keyword_count': keyword_count,
-        'keyword_density': density
-    }
-
-# --- Image Alt Text Generator ---
-def generate_image_alt_texts(keyword, num_sections=5):
-    """Generate alt text suggestions for images based on keyword"""
-    alt_texts = [
-        f"Infographic showing {keyword} overview",
-        f"Step-by-step guide for {keyword}",
-        f"Visual representation of {keyword} benefits",
-        f"Comparison chart related to {keyword}",
-        f"Real-world example of {keyword} in action"
-    ]
-    return alt_texts[:num_sections]
-
-# --- CTA Personalization ---
-def generate_personalized_cta(emotion, tone, keyword):
-    """Generate personalized CTAs based on emotion and tone"""
-    cta_templates = {
-        'Trust': {
-            'Friendly': f"Ready to explore {keyword}? Share your thoughts below!",
-            'Professional': f"Implement these {keyword} strategies and let us know your results.",
-            'Motivational': f"Take action on {keyword} today - your success story starts now!"
-        },
-        'Excitement': {
-            'Friendly': f"Excited about {keyword}? Tell us what you're planning to try first!",
-            'Professional': f"Ready to leverage {keyword}? Connect with our team for expert guidance.",
-            'Motivational': f"Don't wait - start your {keyword} journey today!"
-        },
-        'Curiosity': {
-            'Friendly': f"What's your experience with {keyword}? We'd love to hear from you!",
-            'Professional': f"Have questions about {keyword}? Our experts are here to help.",
-            'Motivational': f"Discover more about {keyword} - your next breakthrough awaits!"
-        },
-        'Confidence': {
-            'Friendly': f"Feel confident about {keyword} now? Share your success story!",
-            'Professional': f"Ready to implement {keyword} with confidence? Get started today.",
-            'Motivational': f"You have everything you need for {keyword} success - take the first step!"
-        },
-        'Inspiration': {
-            'Friendly': f"Feeling inspired about {keyword}? Let's continue the conversation!",
-            'Professional': f"Transform your approach to {keyword} with our proven methods.",
-            'Motivational': f"Your {keyword} transformation starts now - make it happen!"
-        }
-    }
-    
-    return cta_templates.get(emotion, {}).get(tone, f"What are your thoughts on {keyword}? Share below!")
-
-# --- Human Tone Enforcement ---
-def create_human_tone_prompt(keyword, tone, emotion, pov):
-    """Create prompts that enforce human-like writing"""
-    anti_ai_phrases = [
-        "Avoid starting with 'In conclusion', 'In summary', or 'To summarize'",
-        "Don't use phrases like 'delve into', 'dive deep', 'it's worth noting'",
-        "Skip generic openings like 'In today's digital world' or 'In this comprehensive guide'",
-        "Use contractions naturally (don't, won't, can't, you'll)",
-        "Write with personal experience and specific examples",
-        "Vary sentence length - mix short punchy sentences with longer explanatory ones"
-    ]
-    
-    human_elements = [
-        "Include personal anecdotes or relatable scenarios",
-        "Use conversational transitions like 'Here's the thing' or 'But wait, there's more'",
-        "Add rhetorical questions to engage readers",
-        "Include specific numbers, dates, or statistics when relevant",
-        "Use storytelling elements to make points memorable"
-    ]
-    
+# ========== Gemini Prompt Builder ==========
+def build_gemini_prompt(keyword, tone, pov, voice_style, additional_instructions):
     return f"""
-    Write in a genuinely human {tone.lower()} tone with {emotion.lower()} emotion using {pov}.
-    
-    AVOID these AI-like patterns:
-    {chr(10).join('- ' + phrase for phrase in anti_ai_phrases)}
-    
-    INCLUDE these human elements:
-    {chr(10).join('- ' + element for element in human_elements)}
-    
-    Write like you're having a conversation with a friend who asked about {keyword}.
-    """
-
-# --- Error Handling ---
-def safe_api_call(model, prompt, max_retries=3):
-    """Safely call the API with error handling"""
-    for attempt in range(max_retries):
-        try:
-            response = model.generate_content(prompt)
-            if response.text:
-                return response.text
-            else:
-                raise Exception("Empty response from API")
-        except Exception as e:
-            if attempt == max_retries - 1:
-                return f"Error generating content: {str(e)}. Please check your API key and try again."
-            continue
-    return "Failed to generate content after multiple attempts."
-
-# --- Main Article Generation ---
-def generate_article(api_key, keyword, plan, pov, tone, length, emotion, show_titles, show_readability, target_keywords, links_input, cta_text, include_alt_texts, include_faqs):
-    
-    if not api_key or not keyword or not plan:
-        return "Please provide API key, keyword, and SEO plan to generate content."
-    
-    try:
-        genai.configure(api_key=api_key)
-        model = genai.GenerativeModel('gemini-1.5-pro')
-    except Exception as e:
-        return f"Error configuring API: {str(e)}"
-
-    # Generate semantic keywords
-    semantic_keywords = generate_semantic_keywords(keyword)
-    all_keywords = [keyword] + (target_keywords.split(',') if target_keywords else []) + semantic_keywords[:5]
-    
-    # Auto-detect internal link suggestions
-    internal_links = ""
-    if links_input.strip():
-        for line in links_input.strip().splitlines():
-            if ":" in line:
-                anchor, url = line.split(":", 1)
-                internal_links += f'<p><strong>Related:</strong> <a href="{url.strip()}">{anchor.strip()}</a></p>\n'
-
-    # Generate personalized CTA if not provided
-    if not cta_text:
-        cta_text = generate_personalized_cta(emotion, tone, keyword)
-
-    # Human tone enforcement
-    human_tone_guide = create_human_tone_prompt(keyword, tone, emotion, pov)
-    
-    # Compose the enhanced prompt
-    prompt = f"""
-{human_tone_guide}
-
-Generate a comprehensive, WordPress-optimized blog post with proper SEO structure.
-
-ARTICLE REQUIREMENTS:
-- Primary keyword: "{keyword}"
-- Use these related keywords naturally: {', '.join(all_keywords)}
-- Tone: {tone}, POV: {pov}, Emotion: {emotion}
-- Include proper HTML structure for WordPress
-- Length target: {length}
-
-SEO STRUCTURE REQUIRED:
-1. Compelling introduction (hook + keyword in first 100 words)
-2. Multiple H2 sections covering different aspects
-3. {"FAQ section with 3-5 questions" if include_faqs else ""}
-4. Strong conclusion with the CTA
-
-SEO PLAN TO FOLLOW:
-{plan}
-
-INTERNAL LINKS TO INCLUDE:
-{links_input if links_input else "No internal links provided"}
-
-FINAL CTA TO USE:
-{cta_text}
-
-OUTPUT FORMAT:
-Use clean HTML suitable for WordPress. Include <h1>, <h2>, <h3>, <p>, <ul>, <li> tags as needed.
-Make it engaging, informative, and naturally optimized for "{keyword}".
+Write a full-length SEO blog article in English optimized for the keyword: "{keyword}".
+
+Tone: {tone}
+Point of View: {pov}
+Voice Style: {voice_style}
+{f"Additional Instructions: {additional_instructions}" if additional_instructions else ""}
+
+Instructions:
+- Include a compelling <title> and <meta description>.
+- Use HTML tags: <h1>, <h2>, <p>, <ul>, <li>, <meta>, and <title>.
+- Use short paragraphs (max 2-3 sentences).
+- Include variations of the keyword (LSI).
+- The article should be at least 700 words.
+- Keep keyword density natural.
+
+Structure:
+- Title (inside <title>)
+- Meta Description (max 160 characters)
+- <h1> Main heading
+- <h2> Subheadings with rich content
+- <ul> Bullet points if applicable
+- Natural conclusion encouraging engagement
+
+Example format:
+<title>Keyword Mastery in 2025</title>
+<meta name=\"description\" content=\"Learn how to master keywords in 2025 for optimal SEO.\">
+<h1>How to Master Keywords</h1>
+<p>Keyword usage is evolving rapidly...</p>
+
+Ready? Begin:
 """
 
-    # Generate main article
-    article = safe_api_call(model, prompt)
-    if "Error" in article:
-        return article
+# ========== Async Blog Generator ==========
+async def generate_blog(api_key, keyword, tone, pov, voice_style, instructions):
+    prompt = build_gemini_prompt(keyword, tone, pov, voice_style, instructions)
 
-    article = sanitize_for_fstring(article)
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel("gemini-pro")
 
-    # Generate meta description
-    meta_desc_prompt = f"""
-Write a compelling meta description for a blog post about '{keyword}'.
-Requirements:
-- Under 160 characters
-- Include the primary keyword
-- Action-oriented and click-worthy
-- Match the {emotion.lower()} emotion
-
-Content summary: {article[:500]}...
-"""
-    
-    meta_description = safe_api_call(model, meta_desc_prompt)
-    meta_description = sanitize_for_fstring(meta_description.strip().replace("\n", " "))[:160]
-
-    # SEO Title Variations
-    title_prompt = f"""
-Create 3 SEO-optimized blog post titles for '{keyword}' that:
-- Include the primary keyword
-- Evoke {emotion.lower()} emotion
-- Are under 60 characters
-- Use power words and numbers where appropriate
-- Match {tone.lower()} tone
-
-Format as a numbered list.
-"""
-    titles = safe_api_call(model, title_prompt)
-
-    # Advanced readability analysis
-    analysis = analyze_text_advanced(article, keyword)
-    
-    # Generate image alt texts
-    alt_texts = generate_image_alt_texts(keyword) if include_alt_texts else []
-
-    # Build final output
-    result_parts = [
-        "<!-- ✅ WordPress Blog Article Output -->",
-        f"<h1>{keyword.title()}</h1>",
-        article,
-        internal_links,
-        "",
-        "<!-- ✅ Rank Math Meta Description -->",
-        f"<p><strong>Meta Description:</strong> {meta_description}</p>",
-        ""
-    ]
-
-    if show_titles:
-        result_parts.extend([
-            "<!-- ✅ SEO Title Variations -->",
-            f"<p><strong>Title Variations:</strong><br>{titles.replace(chr(10), '<br>')}</p>",
-            ""
-        ])
-
-    if include_alt_texts and alt_texts:
-        result_parts.extend([
-            "<!-- ✅ Image Alt Text Suggestions -->",
-            "<p><strong>Suggested Image Alt Texts:</strong></p>",
-            "<ul>"
-        ])
-        for alt in alt_texts:
-            result_parts.append(f"<li>{alt}</li>")
-        result_parts.extend(["</ul>", ""])
-
-    if show_readability:
-        result_parts.extend([
-            "<!-- ✅ Enhanced Readability & SEO Analysis -->",
-            f"<div style='background:#f8f9fa;padding:15px;border-radius:5px;'>",
-            f"<p><strong>📊 Readability Analysis:</strong></p>",
-            f"<p>• Flesch Reading Ease: {analysis['flesch_score']:.1f} ({analysis['readability_level']})</p>",
-            f"<p>• Gunning Fog Index: {analysis['gunning_fog']:.1f}</p>",
-            f"<p>• Average Sentence Length: {analysis['avg_sentence_length']} words</p>",
-            f"<p><strong>🎯 SEO Metrics:</strong></p>",
-            f"<p>• Keyword '{keyword}' appears {analysis['keyword_count']} times</p>",
-            f"<p>• Keyword Density: {analysis['keyword_density']}% (optimal: 1-2%)</p>",
-            f"<p>• Total Words: {analysis['word_count']}</p>",
-            f"<p>• Total Sentences: {analysis['sentence_count']}</p>",
-            f"</div>",
-            ""
-        ])
-
-    result_parts.extend([
-        "<!-- ✅ Semantic Keywords Used -->",
-        f"<p><strong>🔑 Keywords Integrated:</strong> {', '.join(all_keywords[:10])}</p>"
-    ])
-
-    return '\n'.join(result_parts)
-
-# --- Gradio UI ---
-with gr.Blocks(css="#generate_button { background: #10b981 !important; color: white !important; }") as demo:
-
-    gr.Markdown("## 🧠 SeoPlan2Article v3 — Enhanced SEO-Optimized Blog Generator")
-    gr.Markdown("*Features: Human Tone Enforcement, Semantic SEO, Advanced Readability, Image Alt Texts, Personalized CTAs*")
-
-    with gr.Accordion("🔑 API & SEO Plan", open=True):
-        api_key_input_ui = gr.Textbox(label="Gemini API Key", type="password", placeholder="Paste your Gemini API key here...")
-        primary_keyword_ui = gr.Textbox(label="Primary Keyword", placeholder="e.g., fermented garlic benefits")
-        seo_plan_ui = gr.Textbox(label="SEO Plan or Outline", lines=10, placeholder="Paste detailed outline here...")
-
-    with gr.Row():
-        pov_ui = gr.Dropdown(label="📖 Point of View", choices=["First Person (I/We)", "Second Person (You/Your)", "Third Person (He/She/It/They)"], value="Second Person (You/Your)")
-        tone_ui = gr.Dropdown(label="🎨 Tone", choices=["Friendly", "Professional", "Witty", "Motivational", "Reassuring", "Curious"], value="Friendly")
-        length_ui = gr.Dropdown(label="🧾 Length", choices=["Short", "Standard", "Long", "Very Long"], value="Standard")
-        emotion_ui = gr.Dropdown(label="💬 Emotion", choices=["Trust", "Excitement", "Curiosity", "Confidence", "Inspiration"], value="Confidence")
-
-    with gr.Accordion("🔗 Keywords, Links, CTA", open=False):
-        target_keywords_ui = gr.Textbox(label="Extra Keywords (optional)", placeholder="Comma-separated")
-        links_to_include_ui = gr.Textbox(label="Internal/External Links (Optional)", placeholder="Format: Anchor: URL", lines=4)
-        cta_text_ui = gr.Textbox(label="Custom Call to Action (Leave blank for auto-generated)", placeholder="e.g., Try it yourself and share your tips!")
-
-    with gr.Accordion("⚙️ Enhanced Features", open=False):
-        include_titles_ui = gr.Checkbox(label="Generate 3 SEO Title Variations", value=True)
-        include_readability_ui = gr.Checkbox(label="Include Advanced Readability Analysis", value=True)
-        include_alt_texts_ui = gr.Checkbox(label="Generate Image Alt Text Suggestions", value=True)
-        include_faqs_ui = gr.Checkbox(label="Include FAQ Section", value=True)
-
-    submit_btn = gr.Button("✨ Generate Enhanced Article", elem_id="generate_button")
-    output_ui = gr.HTML("Your generated content will appear here...")
-
-    submit_btn.click(
-        fn=generate_article,
-        inputs=[
-            api_key_input_ui, primary_keyword_ui, seo_plan_ui, pov_ui, tone_ui,
-            length_ui, emotion_ui, include_titles_ui, include_readability_ui,
-            target_keywords_ui, links_to_include_ui, cta_text_ui, include_alt_texts_ui, include_faqs_ui
-        ],
-        outputs=output_ui,
-    )
+    try:
+        response = await model.generate_content_async(prompt)
+        return response.text
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# ========== Gradio UI ==========
+def main():
+    with gr.Blocks(css=".gr-button {margin-top: 10px}") as demo:
+        gr.Markdown("""# 📝 Gemini SEO Blog Writer
+        Generate full HTML blog posts optimized for SEO, powered by Gemini.
+        """)
+
+        with gr.Row():
+            api_key = gr.Textbox(label="Gemini API Key", type="password")
+            keyword = gr.Textbox(label="Primary Keyword")
+
+        with gr.Row():
+            tone = gr.Dropdown(label="Tone", choices=["Neutral", "Professional", "Friendly", "Conversational"], value="Professional")
+            pov = gr.Dropdown(label="Point of View", choices=["First Person", "Second Person", "Third Person"], value="Third Person")
+            voice_style = gr.Dropdown(label="Voice Style", choices=["Formal", "Informal", "Storytelling"], value="Formal")
+
+        additional_instructions = gr.Textbox(label="Additional Instructions (optional)")
+        error_box = gr.Textbox(visible=False, label="Error", interactive=False)
+
+        generate_btn = gr.Button("✨ Generate Blog")
+
+        with gr.Accordion("📄 HTML Blog Output", open=True):
+            blog_output = gr.Textbox(label="Generated HTML", lines=20)
+
+        with gr.Accordion("🔍 Live HTML Preview", open=False):
+            blog_preview = gr.HTML()
+
+        download_btn = gr.Button("⬇️ Download HTML File")
+        file_output = gr.File()
+
+        # Generate blog content
+        def validate_inputs(api_key, keyword):
+            if not api_key:
+                return gr.Textbox.update(visible=True, value="API key is required"), None
+            if not keyword:
+                return gr.Textbox.update(visible=True, value="Keyword is required"), None
+            return gr.Textbox.update(visible=False), keyword
+
+        def sync_blog_preview(blog_text):
+            return blog_text
+
+        generate_btn.click(
+            fn=validate_inputs,
+            inputs=[api_key, keyword],
+            outputs=[error_box, keyword],
+        ).then(
+            fn=generate_blog,
+            inputs=[api_key, keyword, tone, pov, voice_style, additional_instructions],
+            outputs=[blog_output],
+        ).then(
+            fn=sync_blog_preview,
+            inputs=[blog_output],
+            outputs=[blog_preview],
+        )
+
+        # Export button logic
+        def export_html(content):
+            path = "/mnt/data/generated_blog.html"
+            with open(path, "w", encoding="utf-8") as f:
+                f.write(content)
+            return path
+
+        download_btn.click(fn=export_html, inputs=[blog_output], outputs=[file_output])
+
+    demo.launch()
 
-# --- Launch ---
 if __name__ == "__main__":
-    demo.launch(debug=True, show_error=True)
+    main()