Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py - Simplified version that definitely works on HF Spaces
+# app.py - HF Spaces compatible version (Fixed webhook handling)
 import os
 import re
 import json
@@ -6,18 +6,19 @@ from datetime import datetime
 from typing import List, Dict, Any
 
 import gradio as gr
-import requests
+from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
 import asyncio
-from threading import Thread
 
-# Configuration
+# Configuration - Use HF Spaces secrets
 WEBHOOK_SECRET = os.getenv("WEBHOOK_SECRET")
 HF_TOKEN = os.getenv("HF_TOKEN")
 
-# Storage for operations
+# Simple storage for processed tag operations
 tag_operations_store: List[Dict[str, Any]] = []
 
-# Recognized tags
+# Common ML tags that we recognize for auto-tagging
 RECOGNIZED_TAGS = {
     "pytorch", "tensorflow", "jax", "transformers", "diffusers",
     "text-generation", "text-classification", "question-answering",
@@ -29,9 +30,15 @@ RECOGNIZED_TAGS = {
     "video-classification", "reinforcement-learning", "tabular-classification",
     "tabular-regression", "time-series-forecasting", "graph-ml", "robotics",
     "computer-vision", "nlp", "cv", "multimodal", "gguf", "safetensors",
-    "llamacpp", "onnx", "mlx", "machine-learning", "deep-learning"
+    "llamacpp", "onnx", "mlx"
 }
 
+class WebhookEvent(BaseModel):
+    event: Dict[str, str]
+    comment: Dict[str, Any]
+    discussion: Dict[str, Any]
+    repo: Dict[str, str]
+
 def extract_tags_from_text(text: str) -> List[str]:
     """Extract potential tags from discussion text"""
     text_lower = text.lower()
@@ -66,9 +73,9 @@ def extract_tags_from_text(text: str) -> List[str]:
 
     return valid_tags
 
-def process_tags_sync(all_tags: List[str], repo_name: str) -> List[str]:
-    """Process tags using direct HuggingFace Hub API calls (synchronous)"""
-    print(f"🔧 Processing tags: {all_tags} for repo: {repo_name}")
+async def process_tags_directly(all_tags: List[str], repo_name: str) -> List[str]:
+    """Process tags using direct HuggingFace Hub API calls"""
+    print("🔧 Using direct HuggingFace Hub API approach...")
     result_messages = []
     
     if not HF_TOKEN:
@@ -188,7 +195,7 @@ This PR adds the `{tag}` tag to the {repo_type} repository.
         error_msg = f"Processing failed: {str(e)}"
         return [error_msg]
 
-def process_webhook_comment(webhook_data: Dict[str, Any]):
+async def process_webhook_comment(webhook_data: Dict[str, Any]):
     """Process webhook to detect and add tags"""
     try:
         comment_content = webhook_data["comment"]["content"]
@@ -206,11 +213,10 @@ def process_webhook_comment(webhook_data: Dict[str, Any]):
         all_tags = list(set(comment_tags + title_tags))
 
         if not all_tags:
-            print("❌ No tags found")
             return "No recognizable tags found"
 
         print(f"🏷️ Found tags: {all_tags}")
-        result_messages = process_tags_sync(all_tags, repo_name)
+        result_messages = await process_tags_directly(all_tags, repo_name)
 
         # Store interaction
         interaction = {
@@ -235,85 +241,90 @@ def process_webhook_comment(webhook_data: Dict[str, Any]):
         print(f"❌ {error_msg}")
         return error_msg
 
-def handle_webhook_request(request: gr.Request):
-    """Handle webhook via Gradio's request handling"""
+# Create FastAPI app for webhook handling
+app = FastAPI(title="HF Tagging Bot API")
+app.add_middleware(CORSMiddleware, allow_origins=["*"])
+
+@app.post("/webhook")
+async def webhook_handler(request: Request, background_tasks: BackgroundTasks):
+    """Handle HF Hub webhooks"""
+    # Verify webhook secret if configured
+    if WEBHOOK_SECRET:
+        webhook_secret = request.headers.get("X-Webhook-Secret")
+        if webhook_secret != WEBHOOK_SECRET:
+            print("❌ Invalid webhook secret")
+            return {"error": "Invalid webhook secret"}
+
     try:
-        print(f"📥 Received request: {request.method}")
-        
-        if request.method != "POST":
-            return {"error": "Method not allowed"}
-        
-        # Get request data
-        if hasattr(request, 'json') and callable(request.json):
-            payload = request.json()
-        else:
-            # Fallback for different request formats
-            return {"error": "Could not parse JSON"}
-        
-        print(f"📥 Webhook payload: {payload.get('event', {})}")
-        
-        # Verify webhook secret if configured
-        if WEBHOOK_SECRET:
-            webhook_secret = request.headers.get("X-Webhook-Secret")
-            if webhook_secret != WEBHOOK_SECRET:
-                print("❌ Invalid webhook secret")
-                return {"error": "Invalid webhook secret"}
+        payload = await request.json()
+        print(f"📥 Received webhook: {payload.get('event', {})}")
 
         event = payload.get("event", {})
         scope = event.get("scope")
         action = event.get("action")
 
         # Only process discussion comment creation (not PRs)
-        if (scope in ["discussion", "discussion.comment"] and 
+        if (scope == "discussion" and 
             action == "create" and 
             not payload.get("discussion", {}).get("isPullRequest", False)):
             
-            # Process webhook in a separate thread
-            def process_in_background():
-                process_webhook_comment(payload)
-            
-            thread = Thread(target=process_in_background)
-            thread.start()
-            
+            background_tasks.add_task(process_webhook_comment, payload)
             return {"status": "processing"}
 
         return {"status": "ignored"}
-        
     except Exception as e:
         print(f"❌ Webhook error: {e}")
         return {"error": str(e)}
 
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "hf_token_configured": bool(HF_TOKEN),
+        "webhook_secret_configured": bool(WEBHOOK_SECRET),
+        "operations_processed": len(tag_operations_store)
+    }
+
+@app.get("/")
+async def root():
+    return {"message": "HF Tagging Bot is running! Visit /gradio for the interface."}
+
 def create_gradio_interface():
-    """Create Gradio interface"""
+    """Create Gradio interface for monitoring"""
     with gr.Blocks(title="HF Tagging Bot", theme=gr.themes.Soft()) as interface:
         gr.Markdown("# 🏷️ HuggingFace Tagging Bot")
         gr.Markdown("*Automatically adds tags to repositories when mentioned in discussions*")
         
         with gr.Tab("🏠 Status"):
-            status_text = gr.HTML(f"""
-<h2>Bot Configuration</h2>
-<ul>
-<li>🔑 <strong>HF Token</strong>: {'✅ Configured' if HF_TOKEN else '❌ Missing'}</li>
-<li>🔐 <strong>Webhook Secret</strong>: {'✅ Configured' if WEBHOOK_SECRET else '❌ Missing'}</li>
-<li>📊 <strong>Operations Processed</strong>: {len(tag_operations_store)}</li>
-</ul>
-
-<h2>Webhook Endpoint</h2>
-<p><code>https://asmaa105-hf-tagging-bot.hf.space/webhook</code></p>
-
-<h2>Setup Instructions</h2>
-<ol>
-<li>Go to your repository Settings → Webhooks</li>
-<li>Add webhook URL above</li>
-<li>Select "Discussion comments" events</li>
-<li>Add your webhook secret if configured</li>
-</ol>
+            gr.Markdown(f"""
+## Bot Configuration
+- 🔑 **HF Token**: {'✅ Configured' if HF_TOKEN else '❌ Missing'}
+- 🔐 **Webhook Secret**: {'✅ Configured' if WEBHOOK_SECRET else '❌ Missing'}
+- 📊 **Operations Processed**: {len(tag_operations_store)}
+
+## Setup Instructions
+1. **Add webhook to your repository**:
+   - Go to repository Settings → Webhooks
+   - Add webhook URL: `https://your-space-name.hf.space/webhook`
+   - Select "Discussion comments" events
+   - Add your webhook secret (optional)
+
+2. **In discussions, mention tags**:
+   - "Please add tags: pytorch, transformers"
+   - "This needs #pytorch and #text-generation"
+   - "tag: computer-vision"
+
+## Webhook Endpoint
+`POST https://your-space-name.hf.space/webhook`
+
+## Health Check
+Visit: `https://your-space-name.hf.space/health`
             """)
             
         with gr.Tab("📝 Operations Log"):
             def get_recent_operations():
                 if not tag_operations_store:
-                    return "No operations yet. The webhook is ready to receive requests."
+                    return "No operations yet. Configure webhooks and post comments with tags to see activity here."
                 
                 recent = tag_operations_store[-10:]
                 output = []
@@ -336,31 +347,7 @@ def create_gradio_interface():
             refresh_btn = gr.Button("🔄 Refresh Log")
             refresh_btn.click(fn=get_recent_operations, outputs=operations_display)
             
-        with gr.Tab("🧪 Test Webhook"):
-            gr.Markdown("### Test Webhook Processing")
-            test_repo = gr.Textbox(label="Repository", value="asmaa105/streamlitweb1")
-            test_comment = gr.Textbox(label="Test Comment", value="Please add tags: pytorch, transformers", lines=3)
-            test_btn = gr.Button("🔧 Test Processing")
-            test_result = gr.Textbox(label="Result", lines=5, interactive=False)
-            
-            def test_webhook_processing(repo, comment):
-                try:
-                    # Create mock webhook data
-                    mock_webhook = {
-                        "event": {"action": "create", "scope": "discussion"},
-                        "comment": {"content": comment, "author": {"id": "test-user"}},
-                        "discussion": {"title": "Test", "num": 1, "isPullRequest": False},
-                        "repo": {"name": repo}
-                    }
-                    
-                    result = process_webhook_comment(mock_webhook)
-                    return f"✅ Test completed!\n\nResult: {result}"
-                except Exception as e:
-                    return f"❌ Test failed: {str(e)}"
-            
-            test_btn.click(fn=test_webhook_processing, inputs=[test_repo, test_comment], outputs=test_result)
-            
-        with gr.Tab("🏷️ Supported Tags"):
+        with gr.Tab("🏷️ Tags & Testing"):
             gr.Markdown(f"""
 ## Supported Tags ({len(RECOGNIZED_TAGS)} total)
 {', '.join(sorted(RECOGNIZED_TAGS))}
@@ -376,7 +363,7 @@ def create_gradio_interface():
                 label="Test Comment",
                 placeholder="Enter a comment to test tag detection...",
                 lines=3,
-                value="Please add tags: pytorch, transformers"
+                value="This model should have tags: pytorch, text-generation"
             )
             test_output = gr.Textbox(
                 label="Detected Tags",
@@ -401,13 +388,13 @@ def create_gradio_interface():
 # Create the Gradio interface
 demo = create_gradio_interface()
 
-# Add webhook handling via Gradio's API
-if hasattr(demo, 'add_api_route'):
-    demo.add_api_route("/webhook", handle_webhook_request, methods=["POST"])
+# Mount Gradio app to FastAPI
+app = gr.mount_gradio_app(app, demo, path="/")
 
+# This is what HF Spaces will use
 if __name__ == "__main__":
-    print("🚀 HF Tagging Bot - Simplified version starting")
+    print("🚀 HF Tagging Bot - Starting with FastAPI + Gradio")
     print(f"🔑 HF_TOKEN: {'✅ Configured' if HF_TOKEN else '❌ Missing'}")
     print(f"🔐 Webhook Secret: {'✅ Configured' if WEBHOOK_SECRET else '❌ Missing'}")
-    print("🌐 Webhook endpoint: /webhook")
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)