Create app.py

app.py

@@ -0,0 +1,375 @@
+import gradio as gr
+import requests
+import os
+import pandas as pd
+import json
+from typing import List, Dict, Optional
+import time
+from datetime import datetime
+
+class HuggingFaceModelExplorer:
+    def __init__(self):
+        self.hf_token = os.getenv("HF_TOKEN")
+        if not self.hf_token:
+            raise ValueError("HF_TOKEN environment variable is required")
+        
+        self.headers = {"Authorization": f"Bearer {self.hf_token}"}
+        self.base_url = "https://huggingface.co/api"
+        
+    def get_inference_endpoints(self) -> List[Dict]:
+        """Fetch all available inference endpoints"""
+        try:
+            # Get serverless inference API models
+            url = f"{self.base_url}/models"
+            params = {
+                "pipeline_tag": None,
+                "library": None,
+                "sort": "downloads",
+                "direction": -1,
+                "limit": 100,
+                "full": True,
+                "config": True
+            }
+            
+            response = requests.get(url, headers=self.headers, params=params)
+            response.raise_for_status()
+            
+            models = response.json()
+            
+            # Filter models that support inference API
+            inference_models = []
+            for model in models:
+                if self._supports_inference_api(model):
+                    inference_models.append({
+                        "id": model.get("id", "Unknown"),
+                        "pipeline_tag": model.get("pipeline_tag", "Unknown"),
+                        "library_name": model.get("library_name", "Unknown"),
+                        "downloads": model.get("downloads", 0),
+                        "likes": model.get("likes", 0),
+                        "created_at": model.get("createdAt", "Unknown"),
+                        "updated_at": model.get("lastModified", "Unknown"),
+                        "tags": model.get("tags", []),
+                        "inference_status": self._check_inference_status(model.get("id"))
+                    })
+            
+            return inference_models
+            
+        except Exception as e:
+            print(f"Error fetching inference endpoints: {e}")
+            return []
+    
+    def _supports_inference_api(self, model: Dict) -> bool:
+        """Check if a model supports the inference API"""
+        # Models with these pipeline tags typically support inference API
+        supported_pipelines = {
+            "text-generation", "text2text-generation", "fill-mask", 
+            "token-classification", "question-answering", "summarization",
+            "translation", "text-classification", "conversational",
+            "image-classification", "object-detection", "image-segmentation",
+            "text-to-image", "image-to-text", "automatic-speech-recognition",
+            "audio-classification", "voice-activity-detection",
+            "depth-estimation", "feature-extraction"
+        }
+        
+        pipeline_tag = model.get("pipeline_tag")
+        return pipeline_tag in supported_pipelines
+    
+    def _check_inference_status(self, model_id: str) -> str:
+        """Check if inference API is currently available for a model"""
+        try:
+            url = f"https://api-inference.huggingface.co/models/{model_id}"
+            response = requests.get(url, headers=self.headers, timeout=5)
+            
+            if response.status_code == 200:
+                return "✅ Available"
+            elif response.status_code == 503:
+                return "🔄 Loading"
+            else:
+                return "❌ Unavailable"
+        except:
+            return "❓ Unknown"
+    
+    def get_dedicated_endpoints(self) -> List[Dict]:
+        """Fetch dedicated inference endpoints (requires paid plan)"""
+        try:
+            url = f"{self.base_url}/inference-endpoints"
+            response = requests.get(url, headers=self.headers)
+            
+            if response.status_code == 200:
+                endpoints = response.json()
+                return [{
+                    "name": ep.get("name", "Unknown"),
+                    "model_id": ep.get("model", {}).get("repository", "Unknown"),
+                    "status": ep.get("status", "Unknown"),
+                    "created_at": ep.get("created_at", "Unknown"),
+                    "updated_at": ep.get("updated_at", "Unknown"),
+                    "compute": ep.get("compute", {}),
+                    "url": ep.get("url", "")
+                } for ep in endpoints]
+            else:
+                return []
+        except Exception as e:
+            print(f"Error fetching dedicated endpoints: {e}")
+            return []
+    
+    def test_model_inference(self, model_id: str, input_text: str = "Hello, how are you?") -> Dict:
+        """Test inference on a specific model"""
+        try:
+            url = f"https://api-inference.huggingface.co/models/{model_id}"
+            
+            # Determine appropriate payload based on model type
+            payload = {"inputs": input_text}
+            
+            response = requests.post(url, headers=self.headers, json=payload, timeout=30)
+            
+            if response.status_code == 200:
+                result = response.json()
+                return {
+                    "status": "success",
+                    "result": result,
+                    "response_time": response.elapsed.total_seconds()
+                }
+            else:
+                return {
+                    "status": "error",
+                    "error": f"HTTP {response.status_code}: {response.text}",
+                    "response_time": response.elapsed.total_seconds()
+                }
+                
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e),
+                "response_time": None
+            }
+
+def create_interface():
+    explorer = HuggingFaceModelExplorer()
+    
+    def refresh_serverless_models():
+        """Refresh the list of serverless inference models"""
+        models = explorer.get_inference_endpoints()
+        if not models:
+            return "No models found or error occurred"
+        
+        df = pd.DataFrame(models)
+        return df
+    
+    def refresh_dedicated_endpoints():
+        """Refresh the list of dedicated inference endpoints"""
+        endpoints = explorer.get_dedicated_endpoints()
+        if not endpoints:
+            return "No dedicated endpoints found (requires paid plan) or error occurred"
+        
+        df = pd.DataFrame(endpoints)
+        return df
+    
+    def test_model(model_id: str, test_input: str):
+        """Test inference on a selected model"""
+        if not model_id.strip():
+            return "Please enter a model ID"
+        
+        if not test_input.strip():
+            test_input = "Hello, how are you today?"
+        
+        result = explorer.test_model_inference(model_id, test_input)
+        
+        if result["status"] == "success":
+            return f"""
+**Model:** {model_id}
+**Status:** ✅ Success
+**Response Time:** {result['response_time']:.2f}s
+
+**Result:**
+```json
+{json.dumps(result['result'], indent=2)}
+```
+"""
+        else:
+            return f"""
+**Model:** {model_id}
+**Status:** ❌ Error
+**Response Time:** {result['response_time']:.2f}s if result['response_time'] else 'N/A'}
+
+**Error:**
+{result['error']}
+"""
+    
+    def search_models(query: str, pipeline_filter: str = "All"):
+        """Search models by name or tags"""
+        models = explorer.get_inference_endpoints()
+        
+        if query:
+            models = [m for m in models if query.lower() in m['id'].lower() or 
+                     any(query.lower() in tag.lower() for tag in m['tags'])]
+        
+        if pipeline_filter != "All":
+            models = [m for m in models if m['pipeline_tag'] == pipeline_filter]
+        
+        if not models:
+            return "No models found matching your criteria"
+        
+        df = pd.DataFrame(models)
+        return df
+    
+    # Create Gradio interface
+    with gr.Blocks(title="🤗 HuggingFace Inference API Explorer", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🤗 HuggingFace Inference API Explorer
+        
+        Explore all available models on HuggingFace Inference API providers!
+        
+        This space showcases:
+        - **Serverless Inference API**: Free tier models available through HF's inference API
+        - **Dedicated Inference Endpoints**: Private endpoints (requires paid plan)
+        - **Model Testing**: Test any model directly from the interface
+        
+        ---
+        """)
+        
+        with gr.Tabs():
+            # Serverless Models Tab
+            with gr.TabItem("🚀 Serverless Models"):
+                gr.Markdown("### Available Serverless Inference API Models")
+                
+                with gr.Row():
+                    search_query = gr.Textbox(
+                        placeholder="Search models by name or tags...", 
+                        label="Search Query"
+                    )
+                    pipeline_filter = gr.Dropdown(
+                        choices=["All", "text-generation", "text-classification", "question-answering", 
+                                "summarization", "translation", "image-classification", "text-to-image"],
+                        value="All",
+                        label="Pipeline Filter"
+                    )
+                    search_btn = gr.Button("🔍 Search Models")
+                
+                refresh_serverless_btn = gr.Button("🔄 Refresh All Models", variant="primary")
+                serverless_output = gr.Dataframe(
+                    headers=["Model ID", "Pipeline", "Library", "Downloads", "Likes", "Status"],
+                    label="Serverless Models"
+                )
+                
+                search_btn.click(
+                    search_models, 
+                    inputs=[search_query, pipeline_filter], 
+                    outputs=serverless_output
+                )
+                refresh_serverless_btn.click(refresh_serverless_models, outputs=serverless_output)
+            
+            # Dedicated Endpoints Tab
+            with gr.TabItem("🏢 Dedicated Endpoints"):
+                gr.Markdown("### Dedicated Inference Endpoints (Requires Paid Plan)")
+                
+                refresh_dedicated_btn = gr.Button("🔄 Refresh Dedicated Endpoints", variant="primary")
+                dedicated_output = gr.Dataframe(
+                    headers=["Name", "Model ID", "Status", "Created", "URL"],
+                    label="Dedicated Endpoints"
+                )
+                
+                refresh_dedicated_btn.click(refresh_dedicated_endpoints, outputs=dedicated_output)
+            
+            # Model Testing Tab
+            with gr.TabItem("🧪 Test Models"):
+                gr.Markdown("### Test Model Inference")
+                
+                with gr.Row():
+                    model_id_input = gr.Textbox(
+                        placeholder="e.g., microsoft/DialoGPT-medium",
+                        label="Model ID",
+                        info="Enter the full model ID from HuggingFace"
+                    )
+                    test_input = gr.Textbox(
+                        placeholder="Hello, how are you today?",
+                        label="Test Input",
+                        info="Text to send to the model"
+                    )
+                
+                test_btn = gr.Button("🚀 Test Model", variant="primary")
+                test_output = gr.Markdown(label="Test Results")
+                
+                test_btn.click(
+                    test_model,
+                    inputs=[model_id_input, test_input],
+                    outputs=test_output
+                )
+            
+            # Statistics Tab
+            with gr.TabItem("📊 Statistics"):
+                gr.Markdown("### Inference API Statistics")
+                
+                stats_btn = gr.Button("📈 Generate Statistics", variant="primary")
+                
+                def generate_stats():
+                    models = explorer.get_inference_endpoints()
+                    if not models:
+                        return "No data available"
+                    
+                    total_models = len(models)
+                    pipelines = {}
+                    libraries = {}
+                    statuses = {}
+                    
+                    for model in models:
+                        # Count pipelines
+                        pipeline = model['pipeline_tag']
+                        pipelines[pipeline] = pipelines.get(pipeline, 0) + 1
+                        
+                        # Count libraries
+                        library = model['library_name']
+                        libraries[library] = libraries.get(library, 0) + 1
+                        
+                        # Count statuses
+                        status = model['inference_status']
+                        statuses[status] = statuses.get(status, 0) + 1
+                    
+                    # Sort by count
+                    top_pipelines = sorted(pipelines.items(), key=lambda x: x[1], reverse=True)[:10]
+                    top_libraries = sorted(libraries.items(), key=lambda x: x[1], reverse=True)[:10]
+                    
+                    stats_text = f"""
+## 📊 HuggingFace Inference API Statistics
+
+**Total Models Available:** {total_models}
+
+### Top Pipeline Tags:
+{chr(10).join([f"- **{pipeline}**: {count} models" for pipeline, count in top_pipelines])}
+
+### Top Libraries:
+{chr(10).join([f"- **{library}**: {count} models" for library, count in top_libraries])}
+
+### Inference Status Distribution:
+{chr(10).join([f"- **{status}**: {count} models" for status, count in statuses.items()])}
+
+*Last updated: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}*
+"""
+                    return stats_text
+                
+                stats_output = gr.Markdown()
+                stats_btn.click(generate_stats, outputs=stats_output)
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        
+        **Note:** This space requires a HuggingFace token set as the `HF_TOKEN` environment variable.
+        
+        - 🌟 Star this space if you find it useful!
+        - 🐛 Report issues on the Community tab
+        - 📚 Learn more about [HuggingFace Inference API](https://huggingface.co/docs/api-inference/index)
+        """)
+    
+    return demo
+
+if __name__ == "__main__":
+    try:
+        demo = create_interface()
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False
+        )
+    except ValueError as e:
+        print(f"Error: {e}")
+        print("Please set the HF_TOKEN environment variable with your HuggingFace token.")