Create app.py

app.py

@@ -0,0 +1,365 @@
+import gradio as gr
+import google.generativeai as genai
+import textstat
+import re
+import os
+from datetime import datetime
+import tempfile
+
+class PRArticleGenerator:
+    def __init__(self):
+        self.pr_prompt = """
+🔧 SYSTEM ROLE: You are an elite PR content creator and strategic brand storyteller trusted by top agencies, corporate media teams, and high-level entrepreneurs. Your task is to read and transform any provided content, story, or news lead into a **highly polished PR-style article** that mimics the tone, structure, and strategic formatting of elite publications like Forbes, Bloomberg, and Business Insider.
+
+🎯 OBJECTIVE:
+- Convert raw input (facts, story, business news, public figure achievements, etc.) into a **public relations-style news article**.
+- Write in **neutral-positive, professional tone** suitable for public and media consumption.
+- Follow a structure optimized for **reader engagement**, **media authority**, and **SEO discoverability**.
+
+🧠 CONTENT STRATEGY:
+Your output must follow the typical PR-style article structure:
+1. **Headline**: Catchy, clear, and subtly sensational. Include target keyword naturally.
+2. **Lead Paragraph**: Who, what, when, where, and why — as a newsworthy hook.
+3. **Impact Section**: Explain the deal's relevance (economic, public, cultural).
+4. **About the Person/Company**: Short biography with credentials and accomplishments.
+5. **Portfolio Highlights**: List of key acquisitions or achievements.
+6. **Vision or Quote**: Add a forward-looking statement or vision from the person.
+7. **Closing Paragraph**: Recap the significance and future outlook.
+
+✅ SEO OPTIMIZATION:
+- Include the **primary keyword** naturally in:
+  - Title (H1)
+  - First 100 words
+  - 1–2 subheadings
+  - Last 100 words
+- Use **Rank Math-friendly structure**:
+  - Add appropriate **H2** subheadings
+  - Use bullet lists for skimmable value
+  - Maintain readability and engagement
+- Ensure **minimum 600 words** (unless input content is too short)
+- Avoid keyword stuffing — aim for **natural semantic variation** (LSI keywords)
+- Optimize for **search intent**: informational + navigational
+
+🌐 AUDIENCE:
+- Journalists, business professionals, investors, and curious online readers
+- Must feel "official," trustworthy, and newsworthy
+- Tone: authoritative yet accessible (no jargon, no exaggeration)
+
+🎨 FORMATTING RULES:
+- Use proper HTML headings: `<h1>`, `<h2>`, `<p>`, `<ul>`, `<strong>` when needed.
+- Format like a WordPress blog post, ready to paste directly into WordPress editor.
+- If quote is not provided, create one that sounds realistic and vision-driven.
+
+📥 INPUT FORMAT:
+The user will paste raw content, an article, a story draft, or a list of facts.
+
+📤 OUTPUT FORMAT:
+Return a fully structured and SEO-optimized PR-style article, ready for WordPress publishing using Rank Math.
+
+⚠️ DO NOT:
+- Generate listicles, opinion pieces, or promotional fluff
+- Use phrases like "This article was written by AI"
+- Include fake dates or unverifiable claims
+
+🎁 BONUS (if relevant input is provided):
+- Suggest a **meta title** and **meta description** optimized for Rank Math
+- Suggest **target keyword**
+
+Please transform the following content into a professional PR-style article:
+"""
+
+    def setup_gemini(self, api_key):
+        """Configure Gemini API"""
+        try:
+            genai.configure(api_key=api_key)
+            model = genai.GenerativeModel('gemini-1.5-pro')
+            return model, None
+        except Exception as e:
+            return None, f"API Configuration Error: {str(e)}"
+
+    def calculate_readability_score(self, text):
+        """Calculate readability score using textstat and custom PR metrics"""
+        try:
+            # Remove HTML tags for analysis
+            clean_text = re.sub(r'<[^>]+>', '', text)
+            
+            # Basic readability metrics
+            flesch_score = textstat.flesch_reading_ease(clean_text)
+            avg_sentence_length = textstat.avg_sentence_length(clean_text)
+            syllable_count = textstat.avg_syllables_per_word(clean_text)
+            
+            # Custom PR writing metrics
+            pr_score = self.calculate_pr_score(text, clean_text)
+            
+            # Normalize Flesch score to 1-10 scale
+            readability_base = min(10, max(1, (flesch_score / 10)))
+            
+            # Combined score (60% readability, 40% PR best practices)
+            final_score = (readability_base * 0.6) + (pr_score * 0.4)
+            
+            return round(final_score, 1), self.get_improvement_suggestions(flesch_score, avg_sentence_length, syllable_count, text)
+            
+        except Exception as e:
+            return 5.0, f"Error calculating readability: {str(e)}"
+
+    def calculate_pr_score(self, html_text, clean_text):
+        """Calculate score based on PR writing best practices"""
+        score = 0
+        max_score = 10
+        
+        # Check for proper HTML structure (H1, H2 tags)
+        if re.search(r'<h1>', html_text, re.IGNORECASE):
+            score += 1.5
+        if re.search(r'<h2>', html_text, re.IGNORECASE):
+            score += 1.5
+            
+        # Check for bullet points/lists
+        if re.search(r'<ul>|<ol>', html_text, re.IGNORECASE):
+            score += 1
+            
+        # Check for strong/bold text
+        if re.search(r'<strong>|<b>', html_text, re.IGNORECASE):
+            score += 1
+            
+        # Check word count (600+ words is ideal for PR)
+        word_count = len(clean_text.split())
+        if word_count >= 600:
+            score += 2
+        elif word_count >= 400:
+            score += 1.5
+        elif word_count >= 200:
+            score += 1
+            
+        # Check for quotes (professional credibility)
+        if '"' in clean_text and clean_text.count('"') >= 2:
+            score += 1
+            
+        # Check for numbers/statistics (authority building)
+        if re.search(r'\d+%|\$\d+|[\d,]+\s*(million|billion|thousand)', clean_text):
+            score += 1.5
+            
+        # Check for professional language patterns
+        professional_indicators = ['according to', 'announced', 'reported', 'confirmed', 'revealed']
+        if any(indicator in clean_text.lower() for indicator in professional_indicators):
+            score += 0.5
+            
+        return min(max_score, score)
+
+    def get_improvement_suggestions(self, flesch_score, avg_sentence_length, syllable_count, html_text):
+        """Generate specific improvement suggestions"""
+        suggestions = []
+        
+        if flesch_score < 50:
+            suggestions.append("• Simplify complex sentences - aim for 15-20 words per sentence")
+        if avg_sentence_length > 25:
+            suggestions.append("• Break down long sentences for better readability")
+        if syllable_count > 1.8:
+            suggestions.append("• Use simpler words where possible without losing professionalism")
+        if not re.search(r'<h2>', html_text, re.IGNORECASE):
+            suggestions.append("• Add more H2 subheadings to improve structure and SEO")
+        if not re.search(r'<ul>|<ol>', html_text, re.IGNORECASE):
+            suggestions.append("• Include bullet points or lists for better scannability")
+        if len(html_text.split()) < 600:
+            suggestions.append("• Expand content to reach 600+ words for better SEO performance")
+        if html_text.count('"') < 2:
+            suggestions.append("• Add relevant quotes to increase credibility and engagement")
+        if not re.search(r'\d+%|\$\d+|[\d,]+', html_text):
+            suggestions.append("• Include specific numbers, statistics, or financial data for authority")
+        
+        if not suggestions:
+            suggestions.append("• Excellent! Your content meets PR writing best practices.")
+            
+        return "\n".join(suggestions)
+
+    def generate_article(self, api_key, content, max_length=4000):
+        """Generate PR-style article using Gemini API"""
+        if not api_key.strip():
+            return "❌ Error: Please enter your Gemini API key", "", 0.0, "", None
+            
+        if not content.strip():
+            return "❌ Error: Please enter content to transform", "", 0.0, "", None
+            
+        if len(content) > max_length:
+            return f"❌ Error: Content exceeds {max_length} characters limit", "", 0.0, "", None
+
+        model, error = self.setup_gemini(api_key)
+        if error:
+            return f"❌ {error}", "", 0.0, "", None
+
+        try:
+            # Generate article
+            full_prompt = self.pr_prompt + "\n\nCONTENT TO TRANSFORM:\n" + content
+            response = model.generate_content(full_prompt)
+            
+            if not response.text:
+                return "❌ Error: No response generated from API", "", 0.0, "", None
+                
+            article_html = response.text.strip()
+            
+            # Calculate readability score
+            score, suggestions = self.calculate_readability_score(article_html)
+            
+            # Create downloadable file
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"pr_article_{timestamp}.html"
+            
+            # Create temporary file
+            temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.html', delete=False, encoding='utf-8')
+            temp_file.write(f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>PR Article - Generated {datetime.now().strftime("%Y-%m-%d")}</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }}
+        h1 {{ color: #2c3e50; }}
+        h2 {{ color: #34495e; border-bottom: 2px solid #3498db; padding-bottom: 5px; }}
+        p {{ line-height: 1.6; }}
+        ul {{ margin: 15px 0; }}
+        li {{ margin: 5px 0; }}
+    </style>
+</head>
+<body>
+{article_html}
+</body>
+</html>""")
+            temp_file.close()
+            
+            success_msg = f"✅ Article generated successfully! Readability Score: {score}/10"
+            
+            return success_msg, article_html, score, suggestions, temp_file.name
+            
+        except Exception as e:
+            return f"❌ Generation Error: {str(e)}", "", 0.0, "", None
+
+def create_interface():
+    generator = PRArticleGenerator()
+    
+    # Custom CSS for better styling
+    css = """
+    .container { max-width: 1200px; margin: 0 auto; }
+    .header { text-align: center; margin-bottom: 30px; }
+    .score-display { 
+        font-size: 18px; 
+        font-weight: bold; 
+        padding: 10px; 
+        border-radius: 5px; 
+        margin: 10px 0;
+    }
+    .error { color: #e74c3c; }
+    .success { color: #27ae60; }
+    .warning { color: #f39c12; }
+    """
+    
+    with gr.Blocks(css=css, title="PR Article Generator", theme=gr.themes.Soft()) as interface:
+        gr.HTML("""
+        <div class="header">
+            <h1>🎯 Elite PR Article Generator</h1>
+            <p>Transform any content into professional PR-style articles optimized for SEO and media consumption</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.HTML("<h3>📝 Input Configuration</h3>")
+                
+                api_key_input = gr.Textbox(
+                    label="🔑 Gemini API Key",
+                    placeholder="Enter your Gemini 1.5 Pro API key here...",
+                    type="password",
+                    lines=1
+                )
+                
+                content_input = gr.Textbox(
+                    label="📄 Content to Transform",
+                    placeholder="Paste your raw content, news, facts, or story here...\n\nExample:\n- Company announcement\n- Business news\n- Achievement story\n- Product launch details\n- Executive biography",
+                    lines=15,
+                    max_lines=20
+                )
+                
+                with gr.Row():
+                    max_length_slider = gr.Slider(
+                        minimum=1000,
+                        maximum=4000,
+                        value=4000,
+                        step=500,
+                        label="📏 Max Input Length (characters)"
+                    )
+                
+                generate_btn = gr.Button(
+                    "🚀 Generate PR Article", 
+                    variant="primary",
+                    size="lg"
+                )
+                
+            with gr.Column(scale=1):
+                gr.HTML("<h3>📊 Output & Analysis</h3>")
+                
+                status_output = gr.Textbox(
+                    label="📋 Status",
+                    lines=2,
+                    interactive=False
+                )
+                
+                with gr.Row():
+                    score_output = gr.Number(
+                        label="📈 Readability Score",
+                        precision=1,
+                        interactive=False
+                    )
+                
+                suggestions_output = gr.Textbox(
+                    label="💡 Improvement Suggestions",
+                    lines=8,
+                    interactive=False,
+                    placeholder="Suggestions will appear here..."
+                )
+                
+                download_file = gr.File(
+                    label="📥 Download HTML Article",
+                    interactive=False
+                )
+        
+        with gr.Row():
+            with gr.Column():
+                gr.HTML("<h3>🎨 Generated Article Preview</h3>")
+                article_output = gr.HTML(
+                    label="Generated PR Article",
+                    show_label=False
+                )
+        
+        # Event handlers
+        generate_btn.click(
+            fn=generator.generate_article,
+            inputs=[api_key_input, content_input, max_length_slider],
+            outputs=[status_output, article_output, score_output, suggestions_output, download_file]
+        )
+        
+        # Add examples
+        gr.HTML("""
+        <div style="margin-top: 30px; padding: 20px; background-color: #f8f9fa; border-radius: 10px;">
+            <h3>💡 Example Input Content:</h3>
+            <p><strong>Business Acquisition:</strong> "Tech entrepreneur John Smith announced the acquisition of downtown office building for $15M. Smith, who previously founded two successful startups, plans to convert the space into a modern co-working hub."</p>
+            <p><strong>Product Launch:</strong> "AI company releases new software that reduces processing time by 60%. The tool has been tested by 500+ businesses with positive results."</p>
+            <p><strong>Executive Profile:</strong> "Sarah Johnson, CEO of GreenTech Solutions, graduated from MIT and led three successful IPOs. Her company just secured $50M in Series B funding."</p>
+        </div>
+        """)
+    
+    return interface
+
+if __name__ == "__main__":
+    # Install required packages
+    try:
+        import google.generativeai
+        import textstat
+    except ImportError:
+        print("Installing required packages...")
+        os.system("pip install google-generativeai textstat")
+    
+    app = create_interface()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )