Update app.py

app.py

@@ -1,13 +1,13 @@
-# app.py - Main application file for HF Spaces
+# app.py - HF Spaces compatible version
 import os
 import re
 import json
 from datetime import datetime
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any
 
+import gradio as gr
 from fastapi import FastAPI, Request, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
-import gradio as gr
 from pydantic import BaseModel
 
 # Configuration - Use HF Spaces secrets
@@ -89,11 +89,10 @@ async def process_tags_directly(all_tags: List[str], repo_name: str) -> List[str
         
         hf_api = HfApi(token=HF_TOKEN)
         
-        # First, determine what type of repository this is
+        # Determine repository type
         repo_type = None
         repo_info = None
         
-        # Try different repository types
         for repo_type_to_try in ["model", "dataset", "space"]:
             try:
                 print(f"🔍 Trying to access {repo_name} as {repo_type_to_try}...")
@@ -230,7 +229,7 @@ async def process_webhook_comment(webhook_data: Dict[str, Any]):
         }
         tag_operations_store.append(interaction)
 
-        # Keep only last 100 operations to prevent memory issues
+        # Keep only last 100 operations
         if len(tag_operations_store) > 100:
             tag_operations_store.pop(0)
 
@@ -241,47 +240,90 @@ async def process_webhook_comment(webhook_data: Dict[str, Any]):
         print(f"❌ {error_msg}")
         return error_msg
 
+# Create FastAPI app for webhook handling
+fastapi_app = FastAPI(title="HF Tagging Bot API")
+fastapi_app.add_middleware(CORSMiddleware, allow_origins=["*"])
+
+@fastapi_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:
+        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 == "discussion" and 
+            action == "create" and 
+            not payload.get("discussion", {}).get("isPullRequest", False)):
+            
+            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)}
+
+@fastapi_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)
+    }
+
 def create_gradio_interface():
     """Create Gradio interface for monitoring"""
-    with gr.Blocks(title="HF Tagging Bot", theme=gr.themes.Soft()) as demo:
+    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("🏠 Home"):
+        with gr.Tab("🏠 Status"):
             gr.Markdown(f"""
-## Bot Status
+## Bot Configuration
 - 🔑 **HF Token**: {'✅ Configured' if HF_TOKEN else '❌ Missing'}
 - 🔐 **Webhook Secret**: {'✅ Configured' if WEBHOOK_SECRET else '❌ Missing'}
 - 📊 **Operations Processed**: {len(tag_operations_store)}
 
-## How to Use
-1. **Configure webhook** in your repository settings:
-   - Webhook URL: `{os.getenv('SPACE_ID', 'your-space')}.hf.space/webhook`
-   - Events: Discussion comments
-   - Secret: Your webhook secret (optional)
+## 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 like**:
+2. **In discussions, mention tags**:
    - "Please add tags: pytorch, transformers"
-   - "This needs #pytorch and #text-generation tags"
+   - "This needs #pytorch and #text-generation"
    - "tag: computer-vision"
 
-3. **Bot will automatically**:
-   - Detect mentioned tags
-   - Create PRs to add missing tags
-   - Post results in logs
-
 ## Webhook Endpoint
-`POST /{os.getenv('SPACE_ID', 'your-space')}.hf.space/webhook`
+`POST https://your-space-name.hf.space/webhook`
+
+## Health Check
+Visit: `https://your-space-name.hf.space/health`
             """)
             
-        with gr.Tab("📝 Recent Operations"):
+        with gr.Tab("📝 Operations Log"):
             def get_recent_operations():
                 if not tag_operations_store:
-                    return "No operations yet. Waiting for webhook events..."
+                    return "No operations yet. Configure webhooks and post comments with tags to see activity here."
                 
-                recent = tag_operations_store[-10:]  # Last 10 operations
+                recent = tag_operations_store[-10:]
                 output = []
-                for op in reversed(recent):  # Most recent first
+                for op in reversed(recent):
                     output.append(f"""
 **{op['repo']}** - {op['timestamp'][:19]}
 - 👤 Author: {op['comment_author']}
@@ -297,33 +339,26 @@ def create_gradio_interface():
                 interactive=False
             )
             
-            refresh_btn = gr.Button("🔄 Refresh")
+            refresh_btn = gr.Button("🔄 Refresh Log")
             refresh_btn.click(fn=get_recent_operations, outputs=operations_display)
             
-        with gr.Tab("🏷️ Supported Tags"):
+        with gr.Tab("🏷️ Tags & Testing"):
             gr.Markdown(f"""
-## Recognized Tags ({len(RECOGNIZED_TAGS)} total):
-
+## Supported Tags ({len(RECOGNIZED_TAGS)} total)
 {', '.join(sorted(RECOGNIZED_TAGS))}
 
-## Tag Detection Patterns:
+## Tag Detection Examples
 - **Explicit**: `tag: pytorch` or `tags: pytorch, transformers`
 - **Hashtag**: `#pytorch #transformers`
-- **Natural text**: Any mention of recognized tags in text
-
-## Examples:
-- ✅ "This model uses pytorch and transformers"
-- ✅ "Please add tags: computer-vision, object-detection"
-- ✅ "Missing #pytorch #text-generation tags"
-- ✅ "tag: nlp"
+- **Natural**: "This model uses pytorch and transformers"
             """)
-
-        with gr.Tab("🔧 Test"):
+            
             gr.Markdown("### Test Tag Detection")
             test_input = gr.Textbox(
                 label="Test Comment",
                 placeholder="Enter a comment to test tag detection...",
-                lines=3
+                lines=3,
+                value="This model should have tags: pytorch, text-generation"
             )
             test_output = gr.Textbox(
                 label="Detected Tags",
@@ -337,75 +372,23 @@ def create_gradio_interface():
                     return "Enter some text to test"
                 tags = extract_tags_from_text(text)
                 if tags:
-                    return f"Found tags: {', '.join(tags)}"
+                    return f"Found {len(tags)} tags: {', '.join(tags)}"
                 else:
-                    return "No tags detected"
+                    return "No tags detected in this text"
             
             test_btn.click(fn=test_tag_detection, inputs=test_input, outputs=test_output)
 
-    return demo
-
-# 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:
-        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 == "discussion" and 
-            action == "create" and 
-            not payload.get("discussion", {}).get("isPullRequest", False)):
-            
-            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)}
-
-# Health check endpoint
-@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."}
+    return interface
 
-# Create and mount Gradio interface
-gradio_app = create_gradio_interface()
-app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
+# Create the Gradio interface
+demo = create_gradio_interface()
 
-# For HF Spaces, we also need to make the Gradio interface the default
-demo = gradio_app
+# Mount FastAPI to Gradio (for HF Spaces)
+app = gr.mount_gradio_app(fastapi_app, demo, path="/")
 
+# This is the main app that HF Spaces will use
 if __name__ == "__main__":
-    # This runs when testing locally
-    import uvicorn
-    port = int(os.getenv("PORT", 7860))
-    print(f"🚀 Starting HF Tagging Bot on port {port}")
+    print("🚀 HF Tagging Bot - Gradio interface ready")
     print(f"🔑 HF_TOKEN: {'✅ Configured' if HF_TOKEN else '❌ Missing'}")
     print(f"🔐 Webhook Secret: {'✅ Configured' if WEBHOOK_SECRET else '❌ Missing'}")
-    uvicorn.run("app:app", host="0.0.0.0", port=port)
+    demo.launch()