Spaces:
Sleeping
Sleeping
| """ | |
| Enhanced LinkedIn Post Generator | |
| Powered by Google Gemini AI | |
| Features: | |
| - Multiple post formats (Standard, Story, List, Question) | |
| - Industry-specific templates | |
| - Post analytics predictions | |
| - Multiple language support | |
| - Batch generation | |
| - Advanced customization options | |
| Requirements: | |
| google-generativeai==0.3.2 | |
| gradio==4.20.0 | |
| requests==2.31.0 | |
| """ | |
| import gradio as gr | |
| import google.generativeai as genai | |
| import os | |
| import json | |
| import re | |
| from datetime import datetime | |
| from typing import List, Dict, Tuple, Optional | |
| # --- Configuration --- | |
| MODEL = "gemini-2.5-flash" | |
| SUPPORTED_LANGUAGES = { | |
| "English": "en", | |
| "Spanish": "es", | |
| "French": "fr", | |
| "German": "de", | |
| "Portuguese": "pt", | |
| "Italian": "it", | |
| "Dutch": "nl", | |
| "Japanese": "ja", | |
| "Korean": "ko", | |
| "Chinese": "zh" | |
| } | |
| class EnhancedLinkedInGenerator: | |
| def __init__(self, api_key=None): | |
| self.api_key = api_key | |
| self.model = None | |
| if api_key: | |
| self.configure_api(api_key) | |
| def configure_api(self, api_key: str) -> bool: | |
| """Configure Gemini API with provided key""" | |
| try: | |
| genai.configure(api_key=api_key) | |
| self.model = genai.GenerativeModel(MODEL) | |
| self.api_key = api_key | |
| return True | |
| except Exception as e: | |
| print(f"API Configuration Error: {e}") | |
| return False | |
| def extract_response_text(self, response) -> str: | |
| """Robust response text extraction for various Gemini API response formats""" | |
| try: | |
| # Method 1: Simple text accessor (most common) | |
| if hasattr(response, 'text') and response.text: | |
| return response.text | |
| # Method 2: Candidates with parts | |
| if hasattr(response, 'candidates') and response.candidates: | |
| candidate = response.candidates[0] | |
| if hasattr(candidate, 'content') and candidate.content: | |
| if hasattr(candidate.content, 'parts') and candidate.content.parts: | |
| return candidate.content.parts[0].text | |
| # Method 3: Direct parts access | |
| if hasattr(response, 'parts') and response.parts: | |
| return response.parts[0].text | |
| return "❌ Error: Unable to extract text from Gemini response." | |
| except Exception as e: | |
| return f"❌ Error parsing response: {str(e)}" | |
| def get_industry_context(self, industry: str) -> str: | |
| """Get industry-specific context and terminology""" | |
| industry_contexts = { | |
| "Technology": "Use tech terminology, mention innovation, digital transformation, and emerging technologies", | |
| "Healthcare": "Focus on patient care, medical advances, healthcare accessibility, and wellness", | |
| "Finance": "Emphasize financial literacy, market trends, investment strategies, and economic insights", | |
| "Education": "Highlight learning methodologies, educational technology, skill development, and knowledge sharing", | |
| "Marketing": "Discuss brand strategies, customer engagement, digital marketing trends, and creative campaigns", | |
| "Sales": "Focus on relationship building, sales techniques, customer success, and revenue growth", | |
| "HR": "Emphasize talent management, workplace culture, employee engagement, and professional development", | |
| "Consulting": "Highlight problem-solving, strategic thinking, client success stories, and industry expertise", | |
| "Real Estate": "Focus on market trends, property investment, client relationships, and industry insights", | |
| "Retail": "Discuss customer experience, retail innovation, market trends, and brand loyalty", | |
| "Manufacturing": "Emphasize operational efficiency, quality control, supply chain, and industrial innovation", | |
| "Non-Profit": "Focus on social impact, community engagement, fundraising, and mission-driven work" | |
| } | |
| return industry_contexts.get(industry, "Use professional language appropriate for your industry") | |
| def get_post_template(self, post_format: str, tone: str) -> str: | |
| """Get format-specific templates for different post types""" | |
| templates = { | |
| "Standard": f""" | |
| Create a {tone} LinkedIn post with this structure: | |
| 1. **Hook** (1-2 sentences): Start with an attention-grabbing statement or question | |
| 2. **Body** (2-3 paragraphs): Develop the main points with specific examples | |
| 3. **Call to Action**: End with engagement-driving question or action request | |
| 4. **Hashtags**: Include 3-5 relevant hashtags at the end | |
| """, | |
| "Story": f""" | |
| Create a {tone} LinkedIn story post with this structure: | |
| 1. **Opening** (1 sentence): Set the scene with "Recently..." or "Last week..." | |
| 2. **Challenge/Situation** (1-2 sentences): Describe the problem or situation | |
| 3. **Action/Solution** (2-3 sentences): What was done to address it | |
| 4. **Outcome/Lesson** (1-2 sentences): Results and key takeaway | |
| 5. **Question**: Ask readers about their similar experiences | |
| 6. **Hashtags**: Include 3-5 relevant hashtags | |
| """, | |
| "List": f""" | |
| Create a {tone} LinkedIn list post with this structure: | |
| 1. **Introduction** (1-2 sentences): Introduce the list topic | |
| 2. **List Items** (5-7 items): Each with brief explanation | |
| • Use bullet points or numbers | |
| • Keep each point concise but valuable | |
| 3. **Conclusion** (1 sentence): Summarize the value | |
| 4. **Engagement**: Ask which point resonates most | |
| 5. **Hashtags**: Include 3-5 relevant hashtags | |
| """, | |
| "Question": f""" | |
| Create a {tone} LinkedIn question post with this structure: | |
| 1. **Context** (2-3 sentences): Provide background for the question | |
| 2. **Main Question** (1 sentence): Clear, thought-provoking question | |
| 3. **Sub-questions** (2-3 follow-up questions): Guide the discussion | |
| 4. **Your Take** (1-2 sentences): Share your initial thoughts | |
| 5. **Call to Participate**: Encourage comments and discussion | |
| 6. **Hashtags**: Include 3-5 relevant hashtags | |
| """, | |
| "Achievement": f""" | |
| Create a {tone} LinkedIn achievement post with this structure: | |
| 1. **Announcement** (1 sentence): Share the achievement | |
| 2. **Journey** (2-3 sentences): Brief story of how you got there | |
| 3. **Gratitude** (1-2 sentences): Thank people who helped | |
| 4. **Learning** (1-2 sentences): What you learned along the way | |
| 5. **Forward Look**: What's next or how others can achieve similar success | |
| 6. **Hashtags**: Include 3-5 relevant hashtags | |
| """ | |
| } | |
| return templates.get(post_format, templates["Standard"]) | |
| def generate_post(self, | |
| topic: str, | |
| audience: str, | |
| key_points: str, | |
| tone: str, | |
| post_format: str, | |
| industry: str, | |
| language: str, | |
| api_key: str, | |
| include_emoji: bool = True, | |
| post_length: str = "Medium") -> str: | |
| """Generate enhanced LinkedIn post with advanced options""" | |
| # Validate inputs | |
| if not all([topic.strip(), audience.strip(), key_points.strip()]): | |
| return "❌ Error: Please fill in all required fields (Topic, Audience, Key Points)." | |
| if not api_key.strip(): | |
| return "❌ Error: Please provide your Gemini API key." | |
| # Configure API | |
| if not self.configure_api(api_key): | |
| return "❌ Error: Invalid API key. Please check your Gemini API key and try again." | |
| # Format key points | |
| formatted_key_points = "\n".join([f"- {line.strip()}" for line in key_points.split("\n") if line.strip()]) | |
| # Get industry context and post template | |
| industry_context = self.get_industry_context(industry) | |
| post_template = self.get_post_template(post_format, tone) | |
| # Determine post length guidance | |
| length_guidance = { | |
| "Short": "Keep the post concise (100-150 words). Perfect for quick insights.", | |
| "Medium": "Create a medium-length post (150-250 words). Balanced detail and readability.", | |
| "Long": "Write a comprehensive post (250-400 words). Detailed and informative." | |
| } | |
| # Build comprehensive prompt | |
| prompt = f""" | |
| You are an expert LinkedIn content strategist and copywriter with deep understanding of professional social media engagement. | |
| **Your Task:** Create a high-quality LinkedIn post based on the specifications below. | |
| **Post Specifications:** | |
| - **Topic:** {topic} | |
| - **Target Audience:** {audience} | |
| - **Post Format:** {post_format} | |
| - **Tone:** {tone} | |
| - **Industry:** {industry} | |
| - **Language:** {language} | |
| - **Length:** {length_guidance[post_length]} | |
| - **Include Emojis:** {include_emoji} | |
| **Industry Context:** {industry_context} | |
| **Key Points to Include:** | |
| {formatted_key_points} | |
| **Post Structure Guidelines:** | |
| {post_template} | |
| **Additional Requirements:** | |
| 1. **Professional Quality:** Ensure content is polished and error-free | |
| 2. **Engagement Optimization:** Use techniques that encourage likes, comments, and shares | |
| 3. **Value-First:** Every sentence should provide value to the reader | |
| 4. **Authenticity:** Make it sound natural and genuine, not overly promotional | |
| 5. **Visual Appeal:** {"Use relevant emojis strategically to enhance readability" if include_emoji else "Do not use emojis"} | |
| 6. **Language:** Write entirely in {language} | |
| 7. **Hashtag Strategy:** Choose hashtags that are popular but not oversaturated | |
| **Engagement Best Practices:** | |
| - Start with a hook that makes people want to read more | |
| - Use short paragraphs for better mobile readability | |
| - Include specific examples or data when possible | |
| - End with a question or call-to-action that encourages responses | |
| - Make it scannable with bullet points or line breaks | |
| Generate the complete LinkedIn post now: | |
| """ | |
| try: | |
| # Generate the post | |
| response = self.model.generate_content( | |
| prompt, | |
| generation_config=genai.types.GenerationConfig( | |
| temperature=0.7, | |
| top_p=0.9, | |
| max_output_tokens=1500, | |
| ) | |
| ) | |
| # Extract response text | |
| post_content = self.extract_response_text(response) | |
| if post_content.startswith("❌"): | |
| return post_content | |
| # Add metadata | |
| metadata = f""" | |
| **Post Analytics Prediction:** | |
| - **Estimated Reach:** {self.predict_reach(topic, audience, tone)} | |
| - **Best Posting Time:** {self.suggest_posting_time(audience)} | |
| - **Engagement Potential:** {self.predict_engagement(post_format, tone)} | |
| --- | |
| *Generated on {datetime.now().strftime("%Y-%m-%d at %H:%M")} using Enhanced LinkedIn Post Generator* | |
| """ | |
| return f"{post_content}\n\n{metadata}" | |
| except Exception as e: | |
| return f"❌ Error generating post: {str(e)}" | |
| def predict_reach(self, topic: str, audience: str, tone: str) -> str: | |
| """Predict potential reach based on topic and audience""" | |
| # Simplified prediction logic | |
| if "AI" in topic or "technology" in topic.lower(): | |
| return "High (5,000-15,000 impressions)" | |
| elif "business" in topic.lower() or "leadership" in topic.lower(): | |
| return "Medium-High (3,000-10,000 impressions)" | |
| else: | |
| return "Medium (1,000-5,000 impressions)" | |
| def suggest_posting_time(self, audience: str) -> str: | |
| """Suggest optimal posting times based on audience""" | |
| if "executive" in audience.lower() or "ceo" in audience.lower(): | |
| return "Tuesday-Thursday, 8-9 AM or 12-1 PM" | |
| elif "developer" in audience.lower() or "engineer" in audience.lower(): | |
| return "Tuesday-Wednesday, 9-10 AM or 2-3 PM" | |
| else: | |
| return "Tuesday-Thursday, 9 AM-12 PM" | |
| def predict_engagement(self, post_format: str, tone: str) -> str: | |
| """Predict engagement potential""" | |
| engagement_scores = { | |
| "Question": "High", | |
| "Story": "High", | |
| "List": "Medium-High", | |
| "Standard": "Medium", | |
| "Achievement": "Medium" | |
| } | |
| return f"{engagement_scores.get(post_format, 'Medium')} engagement expected" | |
| def generate_multiple_posts(self, | |
| topic: str, | |
| audience: str, | |
| key_points: str, | |
| api_key: str, | |
| count: int = 3) -> str: | |
| """Generate multiple post variations""" | |
| formats = ["Standard", "Story", "Question"] | |
| tones = ["Professional", "Inspirational", "Conversational"] | |
| results = [] | |
| for i in range(min(count, 3)): | |
| post = self.generate_post( | |
| topic=topic, | |
| audience=audience, | |
| key_points=key_points, | |
| tone=tones[i], | |
| post_format=formats[i], | |
| industry="Technology", | |
| language="English", | |
| api_key=api_key, | |
| include_emoji=True, | |
| post_length="Medium" | |
| ) | |
| results.append(f"**Variation {i+1} ({formats[i]} - {tones[i]}):**\n{post}\n\n{'='*50}\n") | |
| return "\n".join(results) | |
| # Initialize generator | |
| generator = EnhancedLinkedInGenerator() | |
| def save_post_to_file(post_content: str, topic: str) -> str: | |
| """Save generated post to downloadable file""" | |
| if not post_content or post_content.startswith("❌"): | |
| return None | |
| timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") | |
| filename = f"linkedin_post_{topic.replace(' ', '_')}_{timestamp}.txt" | |
| with open(filename, 'w', encoding='utf-8') as f: | |
| f.write(post_content) | |
| return filename | |
| # Create the enhanced Gradio interface | |
| with gr.Blocks( | |
| theme=gr.themes.Soft(), | |
| title="Enhanced LinkedIn Post Generator - Powered by Google Gemini AI", | |
| css=""" | |
| .main-header { text-align: center; margin-bottom: 2rem; } | |
| .feature-box { background: linear-gradient(45deg, #667eea, #764ba2); padding: 1rem; border-radius: 8px; color: white; margin: 1rem 0; } | |
| .pro-tip { background: #f0f9ff; padding: 1rem; border-left: 4px solid #3b82f6; margin: 1rem 0; } | |
| """ | |
| ) as demo: | |
| # Header | |
| gr.Markdown(""" | |
| <div class="main-header"> | |
| <h1>🚀 Enhanced LinkedIn Post Generator</h1> | |
| <h3>Powered by Google Gemini AI</h3> | |
| <p>Create professional, engaging LinkedIn content with advanced AI assistance</p> | |
| </div> | |
| """, elem_classes=["main-header"]) | |
| # Feature highlights | |
| gr.Markdown(""" | |
| <div class="feature-box"> | |
| <h4>✨ Advanced Features</h4> | |
| <ul> | |
| <li>🎯 Multiple post formats (Standard, Story, List, Question, Achievement)</li> | |
| <li>🏢 Industry-specific templates and terminology</li> | |
| <li>🌍 Multi-language support (10 languages)</li> | |
| <li>📊 Post analytics predictions</li> | |
| <li>🎨 Customizable tone and length options</li> | |
| <li>📱 Mobile-optimized formatting</li> | |
| </ul> | |
| </div> | |
| """, elem_classes=["feature-box"]) | |
| with gr.Tabs(): | |
| # Single Post Generation Tab | |
| with gr.TabItem("📝 Generate Single Post"): | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| gr.Markdown("## 🔑 API Configuration") | |
| api_key_input = gr.Textbox( | |
| label="Gemini API Key", | |
| placeholder="Enter your Google Gemini API key", | |
| type="password", | |
| info="Get your free API key from: https://aistudio.google.com/app/apikey" | |
| ) | |
| gr.Markdown("## 📋 Basic Information") | |
| topic_input = gr.Textbox( | |
| label="Post Topic *", | |
| placeholder="e.g., 'The Future of Remote Work', 'AI in Healthcare', 'Leadership Lessons'", | |
| lines=1 | |
| ) | |
| audience_input = gr.Textbox( | |
| label="Target Audience *", | |
| placeholder="e.g., 'Software Engineers and Tech Leaders', 'Healthcare Professionals', 'Marketing Executives'", | |
| lines=2 | |
| ) | |
| key_points_input = gr.Textbox( | |
| label="Key Points to Cover *", | |
| placeholder="Enter one key point per line:\n- Main insight or benefit\n- Supporting evidence or example\n- Personal experience or tip\n- Future implications or next steps", | |
| lines=6 | |
| ) | |
| gr.Markdown("## 🎨 Customization Options") | |
| with gr.Row(): | |
| tone_input = gr.Dropdown( | |
| label="Tone of Voice", | |
| choices=[ | |
| "Professional", "Inspirational", "Conversational", | |
| "Thought-provoking", "Educational", "Enthusiastic", | |
| "Analytical", "Motivational", "Friendly", "Authoritative" | |
| ], | |
| value="Professional" | |
| ) | |
| post_format_input = gr.Dropdown( | |
| label="Post Format", | |
| choices=["Standard", "Story", "List", "Question", "Achievement"], | |
| value="Standard", | |
| info="Choose the structure that best fits your content" | |
| ) | |
| with gr.Row(): | |
| industry_input = gr.Dropdown( | |
| label="Industry", | |
| choices=[ | |
| "Technology", "Healthcare", "Finance", "Education", | |
| "Marketing", "Sales", "HR", "Consulting", | |
| "Real Estate", "Retail", "Manufacturing", "Non-Profit" | |
| ], | |
| value="Technology" | |
| ) | |
| language_input = gr.Dropdown( | |
| label="Language", | |
| choices=list(SUPPORTED_LANGUAGES.keys()), | |
| value="English" | |
| ) | |
| with gr.Row(): | |
| post_length_input = gr.Dropdown( | |
| label="Post Length", | |
| choices=["Short", "Medium", "Long"], | |
| value="Medium", | |
| info="Short: 100-150 words, Medium: 150-250 words, Long: 250-400 words" | |
| ) | |
| include_emoji_input = gr.Checkbox( | |
| label="Include Emojis", | |
| value=True, | |
| info="Add emojis to enhance readability and engagement" | |
| ) | |
| generate_button = gr.Button( | |
| "🚀 Generate LinkedIn Post", | |
| variant="primary", | |
| size="lg" | |
| ) | |
| with gr.Column(scale=3): | |
| gr.Markdown("## 📊 Generated Content") | |
| output_post = gr.Markdown( | |
| label="Your LinkedIn Post", | |
| value="Your AI-generated LinkedIn post will appear here...", | |
| show_copy_button=True | |
| ) | |
| with gr.Row(): | |
| download_btn = gr.DownloadButton( | |
| "💾 Download Post", | |
| size="sm", | |
| variant="secondary", | |
| visible=False | |
| ) | |
| regenerate_btn = gr.Button( | |
| "🔄 Regenerate with Same Settings", | |
| size="sm", | |
| variant="secondary" | |
| ) | |
| # Batch Generation Tab | |
| with gr.TabItem("🔄 Generate Multiple Variations"): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("## 📝 Batch Generation") | |
| gr.Markdown("Generate 3 different variations of your post with different formats and tones.") | |
| batch_api_key = gr.Textbox( | |
| label="Gemini API Key", | |
| placeholder="Enter your Google Gemini API key", | |
| type="password" | |
| ) | |
| batch_topic = gr.Textbox( | |
| label="Post Topic", | |
| placeholder="e.g., 'Digital Transformation in Healthcare'" | |
| ) | |
| batch_audience = gr.Textbox( | |
| label="Target Audience", | |
| placeholder="e.g., 'Healthcare IT Directors and Medical Professionals'", | |
| lines=2 | |
| ) | |
| batch_key_points = gr.Textbox( | |
| label="Key Points", | |
| placeholder="Enter key points, one per line", | |
| lines=5 | |
| ) | |
| batch_generate_btn = gr.Button( | |
| "🎯 Generate 3 Variations", | |
| variant="primary" | |
| ) | |
| with gr.Column(scale=2): | |
| batch_output = gr.Markdown( | |
| label="Post Variations", | |
| value="Multiple post variations will appear here...", | |
| show_copy_button=True | |
| ) | |
| # Pro Tips Section | |
| gr.Markdown(""" | |
| <div class="pro-tip"> | |
| <h4>💡 Pro Tips for Better LinkedIn Posts</h4> | |
| <ul> | |
| <li><strong>Hook First:</strong> Your first sentence determines if people read the rest</li> | |
| <li><strong>Value-Driven:</strong> Every post should provide clear value to your audience</li> | |
| <li><strong>Story Format:</strong> Stories get 30x more engagement than standard posts</li> | |
| <li><strong>Question Ending:</strong> Always end with a question to drive comments</li> | |
| <li><strong>Optimal Length:</strong> 150-250 words perform best for engagement</li> | |
| <li><strong>Posting Time:</strong> Tuesday-Thursday, 8 AM-12 PM for best reach</li> | |
| <li><strong>Hashtag Strategy:</strong> Use 3-5 relevant hashtags, mix popular and niche</li> | |
| </ul> | |
| </div> | |
| """, elem_classes=["pro-tip"]) | |
| # Footer | |
| gr.Markdown(""" | |
| --- | |
| ### 🔗 Getting Started | |
| 1. **Get Your API Key:** Visit [Google AI Studio](https://aistudio.google.com/app/apikey) to get your free Gemini API key | |
| 2. **Choose Your Format:** Select the post format that best matches your content type | |
| 3. **Customize Settings:** Adjust tone, industry, and length to match your brand voice | |
| 4. **Generate & Refine:** Create your post and use the regenerate button for variations | |
| **API Usage:** Each post generation uses ~1,000-1,500 tokens. The free tier includes 60 requests per minute. | |
| *Built with ❤️ using Google Gemini AI and Gradio* | |
| """) | |
| # Event handlers | |
| def generate_and_prepare_download(topic, audience, key_points, tone, post_format, | |
| industry, language, post_length, include_emoji, api_key): | |
| # Generate post | |
| post = generator.generate_post( | |
| topic=topic, | |
| audience=audience, | |
| key_points=key_points, | |
| tone=tone, | |
| post_format=post_format, | |
| industry=industry, | |
| language=language, | |
| api_key=api_key, | |
| include_emoji=include_emoji, | |
| post_length=post_length | |
| ) | |
| # Prepare download | |
| if not post.startswith("❌") and topic.strip(): | |
| filename = save_post_to_file(post, topic) | |
| return post, gr.DownloadButton("💾 Download Post", value=filename, visible=True) | |
| else: | |
| return post, gr.DownloadButton("💾 Download Post", visible=False) | |
| def generate_batch_posts(topic, audience, key_points, api_key): | |
| if not api_key.strip(): | |
| return "❌ Error: Please provide your Gemini API key." | |
| return generator.generate_multiple_posts(topic, audience, key_points, api_key, 3) | |
| # Connect event handlers | |
| generate_button.click( | |
| fn=generate_and_prepare_download, | |
| inputs=[topic_input, audience_input, key_points_input, tone_input, | |
| post_format_input, industry_input, language_input, | |
| post_length_input, include_emoji_input, api_key_input], | |
| outputs=[output_post, download_btn] | |
| ) | |
| regenerate_btn.click( | |
| fn=generate_and_prepare_download, | |
| inputs=[topic_input, audience_input, key_points_input, tone_input, | |
| post_format_input, industry_input, language_input, | |
| post_length_input, include_emoji_input, api_key_input], | |
| outputs=[output_post, download_btn] | |
| ) | |
| batch_generate_btn.click( | |
| fn=generate_batch_posts, | |
| inputs=[batch_topic, batch_audience, batch_key_points, batch_api_key], | |
| outputs=[batch_output] | |
| ) | |
| # Launch configuration | |
| if __name__ == "__main__": | |
| print("🚀 Launching Enhanced LinkedIn Post Generator...") | |
| print("✨ Powered by Google Gemini AI") | |
| print("🌟 Advanced Features Enabled") | |
| print("🔑 Get your API key: https://aistudio.google.com/app/apikey") | |
| print() | |
| # Cloud-friendly launch (FIXED) | |
| demo.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| share=False, | |
| show_error=True | |
| ) | |