Create app.py

app.py

@@ -0,0 +1,369 @@
+import gradio as gr
+import requests
+import json
+import os
+import re
+from typing import List, Dict, Optional
+
+# Initialize OpenAI client if available
+openai_client = None
+if os.environ.get("OPENAI_API_KEY"):
+    try:
+        from openai import OpenAI
+        openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+    except ImportError:
+        print("OpenAI library not installed. Install with: pip install openai")
+        openai_client = None
+
+class GradioOutreachAgent:
+    def __init__(self):
+        self.github_token = os.environ.get("GITHUB_TOKEN")
+        
+    def extract_pr_info(self, pr_data: Dict) -> Dict:
+        """Extract key info from PR"""
+        return {
+            "title": pr_data["title"],
+            "description": pr_data.get("body", "") or "",
+            "author": pr_data["user"]["login"],
+            "author_name": pr_data["user"].get("name") or pr_data["user"]["login"],
+            "html_url": pr_data["html_url"],
+            "number": pr_data["number"],
+            "labels": [label["name"] for label in pr_data.get("labels", [])],
+            "merged_at": pr_data.get("merged_at"),
+            "files_changed": self.get_pr_files(pr_data.get("url", "")),
+            "repo_name": pr_data.get("base", {}).get("repo", {}).get("name", "gradio"),
+            "diff_url": pr_data.get("diff_url", ""),
+            "patch_url": pr_data.get("patch_url", ""),
+            "commits": pr_data.get("commits", 0),
+            "additions": pr_data.get("additions", 0),
+            "deletions": pr_data.get("deletions", 0),
+            "changed_files": pr_data.get("changed_files", 0)
+        }
+    
+    def get_pr_files(self, pr_url: str) -> List[Dict]:
+        """Get files changed in PR"""
+        if not pr_url or not self.github_token:
+            return []
+            
+        files_url = f"{pr_url}/files"
+        headers = {"Authorization": f"token {self.github_token}"}
+        
+        try:
+            response = requests.get(files_url, headers=headers)
+            if response.status_code == 200:
+                return response.json()
+        except Exception as e:
+            print(f"Error fetching PR files: {e}")
+        
+        return []
+    
+    def get_pr_diff(self, pr_info: Dict) -> str:
+        """Get PR diff content"""
+        if not pr_info.get("diff_url") or not self.github_token:
+            return ""
+            
+        headers = {"Authorization": f"token {self.github_token}"}
+        
+        try:
+            response = requests.get(pr_info["diff_url"], headers=headers)
+            if response.status_code == 200:
+                # Limit diff size to avoid token limits
+                diff_content = response.text
+                if len(diff_content) > 8000:  # Limit to ~8k characters
+                    diff_content = diff_content[:8000] + "\n... (truncated)"
+                return diff_content
+        except Exception as e:
+            print(f"Error fetching PR diff: {e}")
+        
+        return ""
+    
+    def extract_images_from_pr(self, pr_info: Dict) -> List[str]:
+        """Extract image URLs from PR description and files"""
+        images = []
+        
+        # Extract from PR description with multiple patterns
+        description = pr_info["description"]
+        
+        # Pattern 1: Standard markdown images ![alt](url)
+        img_pattern1 = r'!\[.*?\]\((.*?)\)'
+        img_matches1 = re.findall(img_pattern1, description)
+        
+        # Pattern 2: HTML img tags
+        img_pattern2 = r'<img[^>]+src=["\']([^"\']+)["\']'
+        img_matches2 = re.findall(img_pattern2, description)
+        
+        # Pattern 3: Direct image URLs
+        img_pattern3 = r'https?://[^\s]+\.(?:png|jpg|jpeg|gif|webp|svg)'
+        img_matches3 = re.findall(img_pattern3, description, re.IGNORECASE)
+        
+        # Combine all matches
+        all_matches = img_matches1 + img_matches2 + img_matches3
+        
+        for img_url in all_matches:
+            if img_url.startswith("http"):
+                images.append(img_url)
+        
+        # Extract from changed files
+        for file in pr_info.get("files_changed", []):
+            filename = file["filename"]
+            if any(filename.lower().endswith(ext) for ext in ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg']):
+                if file["status"] in ["added", "modified"]:
+                    # Try to construct the raw URL for the image
+                    raw_url = file.get("raw_url")
+                    if raw_url:
+                        images.append(raw_url)
+        
+        # Remove duplicates while preserving order
+        unique_images = []
+        for img in images:
+            if img not in unique_images:
+                unique_images.append(img)
+        
+        return unique_images
+    
+    def generate_tweet_from_pr_analysis(self, pr_info: Dict) -> str:
+        """Generate tweet by analyzing the entire PR content"""
+        if not openai_client:
+            return self.generate_fallback_tweet(pr_info)
+        
+        # Get PR diff for better understanding
+        diff_content = self.get_pr_diff(pr_info)
+        
+        # Prepare comprehensive PR context
+        files_summary = self.summarize_files_changed(pr_info.get("files_changed", []))
+        
+        prompt = f"""Analyze this GitHub PR and create a viral tweet explaining what was accomplished:
+
+PR DETAILS:
+Title: {pr_info['title']}
+Description: {pr_info['description']}
+Author: {pr_info['author_name']}
+Files Changed: {pr_info['changed_files']} files
+Lines Added: {pr_info['additions']}
+Lines Deleted: {pr_info['deletions']}
+Commits: {pr_info['commits']}
+Labels: {', '.join(pr_info['labels'])}
+Changed Files Summary: {files_summary}
+
+TECHNICAL CHANGES:
+{diff_content}
+
+INSTRUCTIONS:
+1. First understand what this PR actually does - what problem it solves or what feature it adds
+2. Focus on the USER BENEFIT - what can developers/users now do that they couldn't before?
+3. Create a viral tweet that explains the work done in simple, exciting terms
+4. Don't mention the author name
+5. Use emojis and engaging language
+6. Keep it under 280 characters
+7. Make it sound like a breakthrough or useful improvement
+
+Examples of good explanations:
+- "🔥 Gradio now supports [specific feature] - making [task] 10x easier for developers!"
+- "✨ New: [feature] in Gradio! No more [old pain point] - just [new simple way]"
+- "🚀 Game changer: Gradio can now [capability] - this opens up [new possibilities]"
+
+Return only the tweet text, no additional formatting, and no hashtag."""
+
+        try:
+            response = openai_client.chat.completions.create(
+                model="gpt-4.1-mini",
+                messages=[
+                    {"role": "system", "content": "You are a technical social media expert who analyzes code changes and explains them in engaging, accessible terms. Focus on practical benefits and make complex technical work sound exciting and useful."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=200,
+                temperature=0.7
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            print(f"OpenAI error: {e}")
+            return self.generate_fallback_tweet(pr_info)
+    
+    def generate_fallback_tweet(self, pr_info: Dict) -> str:
+        """Generate fallback tweet when OpenAI is not available"""
+        title = pr_info['title'].lower()
+        pr_title = pr_info['title']
+        
+        # Extract key features/benefits from title
+        if 'api' in title and 'description' in title:
+            return f"🔥 Gradio now auto-generates API documentation! No more manual docs - just add one parameter and get beautiful API descriptions instantly ✨ #gradio #ai #developer"
+        elif 'add' in title and 'parameter' in title:
+            return f"✨ New Gradio parameter unlocked! You can now {pr_title.lower().replace('add ', '').replace('parameter', 'customize')} - making your apps even more powerful 🚀 #gradio #nocode"
+        elif 'fix' in title or 'bug' in title:
+            return f"🔧 Gradio just got more reliable! Fixed the issue where {pr_title.lower().replace('fix ', '').replace('bug', 'things')} - smoother experience for everyone 💪 #gradio #ai"
+        elif 'support' in title or 'enable' in title:
+            return f"🚀 Breaking: Gradio now supports {pr_title.lower().replace('add support for ', '').replace('enable ', '')}! This opens up so many new possibilities 🌟 #gradio #ai"
+        elif 'improve' in title or 'enhance' in title:
+            return f"⚡ Gradio upgrade: {pr_title.lower().replace('improve ', '').replace('enhance ', '')} just got way better! Your apps will feel snappier than ever 🔥 #gradio #performance"
+        elif 'allow' in title or 'let' in title:
+            return f"✨ You can now {pr_title.lower().replace('allow ', '').replace('let ', '')} in Gradio! This is exactly what the community asked for 🎉 #gradio #ai"
+        else:
+            # Generic viral template
+            benefit = self.extract_benefit_from_title(pr_title)
+            return f"🔥 Gradio just leveled up! {benefit} - this changes everything for AI app builders 🚀 #gradio #ai #machinelearning"
+    
+    def extract_benefit_from_title(self, title: str) -> str:
+        """Extract user benefit from PR title"""
+        # Simple benefit extraction
+        if 'add' in title.lower():
+            return f"New feature: {title.replace('Add ', '').replace('add ', '')}"
+        elif 'fix' in title.lower():
+            return f"No more issues with {title.replace('Fix ', '').replace('fix ', '')}"
+        elif 'support' in title.lower():
+            return f"Full support for {title.replace('Add support for ', '').replace('support for ', '')}"
+        else:
+            return title
+    
+    def summarize_files_changed(self, files: List[Dict]) -> str:
+        """Summarize what files were changed"""
+        if not files:
+            return "No files changed"
+        
+        categories = {
+            "Python backend": [],
+            "Frontend (JS/CSS)": [],
+            "Documentation": [],
+            "Tests": [],
+            "Examples": [],
+            "Config": []
+        }
+        
+        for file in files:
+            filename = file["filename"]
+            if filename.endswith('.py'):
+                categories["Python backend"].append(filename)
+            elif any(filename.endswith(ext) for ext in ['.js', '.jsx', '.ts', '.tsx', '.css', '.scss']):
+                categories["Frontend (JS/CSS)"].append(filename)
+            elif filename.endswith('.md') or 'readme' in filename.lower():
+                categories["Documentation"].append(filename)
+            elif 'test' in filename.lower():
+                categories["Tests"].append(filename)
+            elif 'example' in filename.lower() or 'demo' in filename.lower():
+                categories["Examples"].append(filename)
+            else:
+                categories["Config"].append(filename)
+        
+        summary_parts = []
+        for category, file_list in categories.items():
+            if file_list:
+                summary_parts.append(f"{category}: {len(file_list)} files")
+        
+        return ", ".join(summary_parts) if summary_parts else "misc files"
+
+# Initialize agent
+agent = GradioOutreachAgent()
+
+def generate_tweet_from_pr(pr_url: str) -> tuple:
+    """Generate tweet from PR URL by analyzing the entire PR"""
+    try:
+        # Validate PR URL
+        if not pr_url or 'github.com' not in pr_url or '/pull/' not in pr_url:
+            return "❌ Please provide a valid GitHub PR URL", []
+        
+        # Extract PR number from URL
+        pr_match = re.search(r'/pull/(\d+)', pr_url)
+        if not pr_match:
+            return "❌ Invalid PR URL format", []
+        
+        pr_number = pr_match.group(1)
+        
+        # Convert to API URL
+        api_url = pr_url.replace('github.com', 'api.github.com/repos').replace('/pull/', '/pulls/')
+        
+        # Set up headers
+        headers = {}
+        if agent.github_token:
+            headers["Authorization"] = f"token {agent.github_token}"
+        
+        # Fetch PR data
+        response = requests.get(api_url, headers=headers)
+        if response.status_code != 200:
+            return f"❌ Failed to fetch PR data (Status: {response.status_code})", []
+        
+        pr_data = response.json()
+        
+        # Check if PR is merged
+        if not pr_data.get("merged", False):
+            return "⚠️ This PR is not merged yet", []
+        
+        # Extract PR info
+        pr_info = agent.extract_pr_info(pr_data)
+        
+        # Generate tweet by analyzing the entire PR
+        tweet = agent.generate_tweet_from_pr_analysis(pr_info)
+        
+        # Extract images
+        images = agent.extract_images_from_pr(pr_info)
+        
+        # Ensure images is a proper list for gallery
+        if not images:
+            images = []
+        
+        return tweet, images
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}", []
+
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("# 🐦 Gradio PR Outreach : Tweet Generator")
+    gr.Markdown("Generate viral format tweets for merged Gradio PRs! This tool will analyze the entire PR content and try to create an engaging tweet explaining what was accomplished.")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            pr_url_input = gr.Textbox(
+                label="🔗 Merged PR URL",
+                placeholder="https://github.com/gradio-app/gradio/pull/11578",
+                value="https://github.com/gradio-app/gradio/pull/11578",
+                lines=1
+            )
+            
+            generate_button = gr.Button("✨ Analyze PR & Generate Tweet", variant="primary")
+        
+        with gr.Column(scale=1):
+            if not openai_client:
+                gr.Markdown("⚠️ **OpenAI API key not configured**\nAdd `OPENAI_API_KEY` to environment variables for better tweet generation.")
+            else:
+                gr.Markdown("✅ **Using OpenAI gpt-4.1-mini to analyze PRs!**")
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            tweet_output = gr.Textbox(
+                label="🐦 Generated Tweet",
+                lines=6,
+                interactive=True,
+                placeholder="AI-generated tweet will appear here..."
+            )
+            
+            gr.Markdown("*💡 Tip: You can edit the tweet above before posting and also use the extracted images for your post!*")
+            
+        with gr.Column(scale=2):
+            images_output = gr.Gallery(
+                label="🖼️ Extracted Images",
+                height=400,
+                columns=2,
+                object_fit="cover"
+            )
+    
+    generate_button.click(
+        generate_tweet_from_pr,
+        inputs=[pr_url_input],
+        outputs=[tweet_output, images_output]
+    )
+    
+    # Adding examples 
+    gr.Examples(
+        examples=[
+            ["https://github.com/gradio-app/gradio/pull/11578"],
+            ["https://github.com/gradio-app/gradio/pull/11567"],
+            ["https://github.com/gradio-app/gradio/pull/11532"]
+        ],
+        inputs=[pr_url_input],
+        outputs=[tweet_output, images_output],
+        fn=generate_tweet_from_pr,
+        cache_examples=False,
+        label="🎯 Example PRs to Try:"
+    )
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)