Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py - HF Spaces compatible version (Fixed webhook handling)
+# app.py - Simplified version that definitely works on HF Spaces
 import os
 import re
 import json
@@ -6,19 +6,18 @@ from datetime import datetime
 from typing import List, Dict, Any
 
 import gradio as gr
-from fastapi import FastAPI, Request, BackgroundTasks
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
+import requests
 import asyncio
+from threading import Thread
 
-# Configuration - Use HF Spaces secrets
+# Configuration
 WEBHOOK_SECRET = os.getenv("WEBHOOK_SECRET")
 HF_TOKEN = os.getenv("HF_TOKEN")
 
-# Simple storage for processed tag operations
+# Storage for operations
 tag_operations_store: List[Dict[str, Any]] = []
 
-# Common ML tags that we recognize for auto-tagging
+# Recognized tags
 RECOGNIZED_TAGS = {
     "pytorch", "tensorflow", "jax", "transformers", "diffusers",
     "text-generation", "text-classification", "question-answering",
@@ -30,15 +29,9 @@ 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"
+    "llamacpp", "onnx", "mlx", "machine-learning", "deep-learning"
 }
 
-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()
@@ -73,9 +66,9 @@ def extract_tags_from_text(text: str) -> List[str]:
 
     return valid_tags
 
-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...")
+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}")
     result_messages = []
     
     if not HF_TOKEN:
@@ -195,7 +188,7 @@ This PR adds the `{tag}` tag to the {repo_type} repository.
         error_msg = f"Processing failed: {str(e)}"
         return [error_msg]
 
-async def process_webhook_comment(webhook_data: Dict[str, Any]):
+def process_webhook_comment(webhook_data: Dict[str, Any]):
     """Process webhook to detect and add tags"""
     try:
         comment_content = webhook_data["comment"]["content"]
@@ -213,10 +206,11 @@ async 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 = await process_tags_directly(all_tags, repo_name)
+        result_messages = process_tags_sync(all_tags, repo_name)
 
         # Store interaction
         interaction = {
@@ -241,90 +235,85 @@ async def process_webhook_comment(webhook_data: Dict[str, Any]):
         print(f"❌ {error_msg}")
         return error_msg
 
-# 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"}
-
+def handle_webhook_request(request: gr.Request):
+    """Handle webhook via Gradio's request handling"""
     try:
-        payload = await request.json()
-        print(f"📥 Received webhook: {payload.get('event', {})}")
+        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"}
 
         event = payload.get("event", {})
         scope = event.get("scope")
         action = event.get("action")
 
         # Only process discussion comment creation (not PRs)
-        if (scope == "discussion" and 
+        if (scope in ["discussion", "discussion.comment"] and 
             action == "create" and 
             not payload.get("discussion", {}).get("isPullRequest", False)):
             
-            background_tasks.add_task(process_webhook_comment, payload)
+            # Process webhook in a separate thread
+            def process_in_background():
+                process_webhook_comment(payload)
+            
+            thread = Thread(target=process_in_background)
+            thread.start()
+            
             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 for monitoring"""
+    """Create Gradio interface"""
     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"):
-            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`
+            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>
             """)
             
         with gr.Tab("📝 Operations Log"):
             def get_recent_operations():
                 if not tag_operations_store:
-                    return "No operations yet. Configure webhooks and post comments with tags to see activity here."
+                    return "No operations yet. The webhook is ready to receive requests."
                 
                 recent = tag_operations_store[-10:]
                 output = []
@@ -347,7 +336,31 @@ Visit: `https://your-space-name.hf.space/health`
             refresh_btn = gr.Button("🔄 Refresh Log")
             refresh_btn.click(fn=get_recent_operations, outputs=operations_display)
             
-        with gr.Tab("🏷️ Tags & Testing"):
+        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"):
             gr.Markdown(f"""
 ## Supported Tags ({len(RECOGNIZED_TAGS)} total)
 {', '.join(sorted(RECOGNIZED_TAGS))}
@@ -363,7 +376,7 @@ Visit: `https://your-space-name.hf.space/health`
                 label="Test Comment",
                 placeholder="Enter a comment to test tag detection...",
                 lines=3,
-                value="This model should have tags: pytorch, text-generation"
+                value="Please add tags: pytorch, transformers"
             )
             test_output = gr.Textbox(
                 label="Detected Tags",
@@ -388,13 +401,13 @@ Visit: `https://your-space-name.hf.space/health`
 # Create the Gradio interface
 demo = create_gradio_interface()
 
-# Mount Gradio app to FastAPI
-app = gr.mount_gradio_app(app, demo, path="/")
+# Add webhook handling via Gradio's API
+if hasattr(demo, 'add_api_route'):
+    demo.add_api_route("/webhook", handle_webhook_request, methods=["POST"])
 
-# This is what HF Spaces will use
 if __name__ == "__main__":
-    print("🚀 HF Tagging Bot - Starting with FastAPI + Gradio")
+    print("🚀 HF Tagging Bot - Simplified version starting")
     print(f"🔑 HF_TOKEN: {'✅ Configured' if HF_TOKEN else '❌ Missing'}")
     print(f"🔐 Webhook Secret: {'✅ Configured' if WEBHOOK_SECRET else '❌ Missing'}")
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    print("🌐 Webhook endpoint: /webhook")
+    demo.launch(server_name="0.0.0.0", server_port=7860)