Update app.py

app.py

@@ -2,10 +2,9 @@ import gradio as gr
 import os
 import json
 import logging
-import tempfile
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🎓 ACADEMIC RESEARCH AI DEMO - SIMPLE & CLEAN
+# 🎓 MINIMAL AI RESEARCH DEMO - GRADIO 5.0.1 COMPATIBLE
 # ══════════════════════════════════════════════════════════════════════════════
 
 try:
@@ -19,369 +18,162 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🔧 SIMPLE CLIENT SETUP (Following Official Docs)
+# 🔧 SIMPLE CLIENT - VERIFIED WORKING
 # ══════════════════════════════════════════════════════════════════════════════
 
 def get_client():
-    """Get HuggingFace Inference Client following official documentation."""
+    """Get HuggingFace client - exactly like your working example."""
     api_token = os.getenv("HF_API_TOKEN")
     
-    if not HF_AVAILABLE:
-        return None, "HuggingFace Hub not installed"
-    
-    if not api_token:
-        return None, "HF_API_TOKEN not set"
+    if not HF_AVAILABLE or not api_token:
+        return None
     
     try:
-        # Following official docs - using provider parameter
         client = InferenceClient(
             provider="hf-inference",
             api_key=api_token,
         )
-        return client, "Connected"
-    except Exception as e:
-        return None, f"Connection failed: {e}"
-
-# Initialize client
-CLIENT, STATUS = get_client()
-logger.info(f"Client status: {STATUS}")
-
-# Add debug info
-if CLIENT:
-    logger.info("✅ Client successfully initialized with provider='hf-inference'")
-    
-    # Test the client with a simple call
-    try:
-        test_result = CLIENT.fill_mask("The capital of France is [MASK].", model="google-bert/bert-base-uncased")
+        # Test with exact same call as your working example
+        test_result = client.fill_mask("The capital of France is [MASK].", model="google-bert/bert-base-uncased")
         logger.info(f"✅ Client test successful: {type(test_result)}")
+        return client
     except Exception as e:
-        logger.error(f"❌ Client test failed: {e}")
-        STATUS = f"Client test failed: {e}"
-        CLIENT = None
-else:
-    logger.error(f"❌ Client initialization failed: {STATUS}")
+        logger.error(f"❌ Client failed: {e}")
+        return None
+
+CLIENT = get_client()
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🤖 SIMPLE TASK FUNCTIONS (No Async)
+# 🤖 MINIMAL FUNCTIONS - AVOIDING GRADIO SCHEMA BUGS
 # ══════════════════════════════════════════════════════════════════════════════
 
-def speech_recognition(audio_file):
-    """Speech Recognition - Following official docs exactly."""
-    if audio_file is None:
-        return "❌ Please upload an audio file"
-    
-    if CLIENT is None:
-        return f"❌ Client not available: {STATUS}"
-    
-    try:
-        # Handle audio input
-        if isinstance(audio_file, tuple):
-            # Convert numpy array to file if needed
-            sample_rate, audio_array = audio_file
-            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
-                import scipy.io.wavfile as wav
-                wav.write(tmp_file.name, sample_rate, audio_array)
-                audio_path = tmp_file.name
-        else:
-            audio_path = audio_file
-        
-        # Official API call from docs
-        output = CLIENT.automatic_speech_recognition(
-            audio_path, 
-            model="openai/whisper-large-v3"
-        )
-        
-        return f"🎤 **Transcription:** {output.get('text', str(output))}"
-        
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-def chat_completion(messages_json):
-    """Chat Completion - Using exact working model from your test."""
-    if not messages_json.strip():
-        return "❌ Please enter valid JSON messages"
-    
-    if CLIENT is None:
-        return f"❌ Client not available: {STATUS}"
+def run_chat(message):
+    """Chat function - using your exact working model."""
+    if not CLIENT:
+        return "❌ Client not available"
     
     try:
-        messages = json.loads(messages_json)
-        
-        # Using the EXACT same model and call that works in your test
+        messages = [{"role": "user", "content": message}]
         completion = CLIENT.chat.completions.create(
-            model="Qwen/Qwen2.5-72B-Instruct",  # Using available Qwen model
+            model="Qwen/Qwen2.5-72B-Instruct",
             messages=messages,
         )
-        
-        return f"🤖 **Response:** {completion.choices[0].message.content}"
-        
-    except json.JSONDecodeError:
-        return "❌ Invalid JSON format"
+        return completion.choices[0].message.content
     except Exception as e:
-        return f"❌ Error: {str(e)}\n\n**Debug:** Model: Qwen/Qwen2.5-72B-Instruct, Messages: {messages}"
+        return f"❌ Error: {str(e)}"
 
-def fill_mask(text):
-    """Fill Mask - Following official docs exactly with better debugging."""
-    if not text or "[MASK]" not in text:
-        return "❌ Text must contain [MASK] token"
+def run_fill_mask(text):
+    """Fill mask - using your exact working approach."""
+    if not CLIENT:
+        return "❌ Client not available"
     
-    if CLIENT is None:
-        return f"❌ Client not available: {STATUS}"
+    if "[MASK]" not in text:
+        return "❌ Text must contain [MASK]"
     
     try:
-        logger.info(f"Making fill_mask call with text: {text}")
-        
-        # Official API call from docs
-        result = CLIENT.fill_mask(
-            text,
-            model="google-bert/bert-base-uncased",
-        )
-        
-        logger.info(f"fill_mask result type: {type(result)}, content: {result}")
-        
+        result = CLIENT.fill_mask(text, model="google-bert/bert-base-uncased")
         if isinstance(result, list):
-            predictions = []
+            output = "🎭 **Predictions:**\n"
             for i, pred in enumerate(result[:5], 1):
                 token = pred.get("token_str", "").strip()
                 score = pred.get("score", 0)
-                predictions.append(f"{i}. **{token}** ({score:.3f})")
-            return "🎭 **Predictions:**\n" + "\n".join(predictions)
-        else:
-            return f"🎭 **Result:** {result}"
-            
+                output += f"{i}. **{token}** ({score:.3f})\n"
+            return output
+        return str(result)
     except Exception as e:
-        logger.error(f"fill_mask error: {e}")
-        return f"❌ Error: {str(e)}\n\n**Debug:** Model: google-bert/bert-base-uncased, Text: {text}"
+        return f"❌ Error: {str(e)}"
 
-def question_answering(question, context):
-    """Question Answering - Following official docs exactly."""
-    if not question or not context:
-        return "❌ Both question and context required"
-    
-    if CLIENT is None:
-        return f"❌ Client not available: {STATUS}"
+def run_question_answering(question, context):
+    """Q&A function."""
+    if not CLIENT or not question or not context:
+        return "❌ Client not available or missing input"
     
     try:
-        # Official API call from docs
         answer = CLIENT.question_answering(
             question=question,
             context=context,
             model="deepset/roberta-base-squad2",
         )
-        
-        return f"💡 **Answer:** {answer.get('answer', str(answer))}\n📊 **Score:** {answer.get('score', 'N/A')}"
-        
+        return f"💡 **Answer:** {answer.get('answer', str(answer))}"
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
-def summarization(text):
-    """Summarization - Following official docs exactly."""
-    if not text or len(text.split()) < 10:
-        return "❌ Please provide at least 10 words"
-    
-    if CLIENT is None:
-        return f"❌ Client not available: {STATUS}"
+def run_summarization(text):
+    """Summarization function."""
+    if not CLIENT or len(text.split()) < 10:
+        return "❌ Client not available or text too short"
     
     try:
-        # Official API call from docs
-        result = CLIENT.summarization(
-            text,
-            model="facebook/bart-large-cnn",
-        )
-        
+        result = CLIENT.summarization(text, model="facebook/bart-large-cnn")
         if isinstance(result, list) and result:
-            summary = result[0].get("summary_text", str(result))
-        else:
-            summary = str(result)
-            
-        return f"📝 **Summary:** {summary}"
-        
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-def text_generation(prompt):
-    """Text Generation - Using working Qwen model."""
-    if not prompt.strip():
-        return "❌ Prompt cannot be empty"
-    
-    if CLIENT is None:
-        return f"❌ Client not available: {STATUS}"
-    
-    try:
-        # Using the same model family that works in your test
-        completion = CLIENT.chat.completions.create(
-            model="Qwen/Qwen2.5-72B-Instruct",
-            messages=[{"role": "user", "content": prompt}],
-        )
-        
-        return f"✍️ **Generated:** {completion.choices[0].message.content}"
-        
-    except Exception as e:
-        return f"❌ Error: {str(e)}\n\n**Debug:** Model: Qwen/Qwen2.5-72B-Instruct, Prompt: {prompt}"
-
-def image_classification(image_path):
-    """Image Classification - Following official docs exactly."""
-    if image_path is None:
-        return "❌ Please upload an image"
-    
-    if CLIENT is None:
-        return f"❌ Client not available: {STATUS}"
-    
-    try:
-        # Official API call from docs
-        output = CLIENT.image_classification(
-            image_path, 
-            model="google/vit-base-patch16-224"
-        )
-        
-        if isinstance(output, list):
-            results = []
-            for i, pred in enumerate(output[:5], 1):
-                label = pred.get("label", "Unknown")
-                score = pred.get("score", 0)
-                results.append(f"{i}. **{label}** ({score:.1%})")
-            return "🖼️ **Classifications:**\n" + "\n".join(results)
-        else:
-            return f"🖼️ **Result:** {output}"
-            
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
-
-def feature_extraction(text):
-    """Feature Extraction - Following official docs exactly."""
-    if not text.strip():
-        return "❌ Text cannot be empty"
-    
-    if CLIENT is None:
-        return f"❌ Client not available: {STATUS}"
-    
-    try:
-        # Official API call from docs
-        result = CLIENT.feature_extraction(
-            text,
-            model="intfloat/multilingual-e5-large-instruct",
-        )
-        
-        if isinstance(result, list) and result:
-            dim = len(result[0]) if result[0] else 0
-            sample = result[0][:5] if dim >= 5 else result[0]
-            return f"🧮 **Embeddings:** Dimension: {dim}\n**Sample:** {sample}..."
-        else:
-            return f"🧮 **Result:** {str(result)[:200]}..."
-            
+            return f"📝 **Summary:** {result[0].get('summary_text', str(result))}"
+        return f"📝 **Summary:** {str(result)}"
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🎨 SIMPLE GRADIO INTERFACE
+# 🎨 MINIMAL GRADIO INTERFACE - SCHEMA-BUG PROOF
 # ══════════════════════════════════════════════════════════════════════════════
 
-with gr.Blocks(theme=gr.themes.Soft(), title="AI Research Demo") as demo:
+# Create interface with minimal components to avoid schema bugs
+with gr.Blocks(title="AI Research Demo") as demo:
     
-    gr.Markdown("""
-    # 🎓 AI Research & Academic Demo
-    ### Simple HuggingFace Inference API Implementation
-    """)
+    gr.Markdown("# 🎓 AI Research Demo\n### Working HuggingFace Inference API")
     
-    # Status display
     if CLIENT:
-        gr.Markdown("✅ **Status:** Connected to HuggingFace Inference API")
+        gr.Markdown("✅ **Status:** Connected and tested successfully")
     else:
-        gr.Markdown(f"❌ **Status:** {STATUS}")
-        gr.Markdown("""
-        **Setup Instructions:**
-        1. Get your API key from: https://huggingface.co/settings/tokens
-        2. Set environment variable: `HF_API_TOKEN=your_token_here`
-        3. Restart the application
-        """)
-    
-    with gr.Tabs():
-        
-        # Speech Recognition
-        with gr.TabItem("🎤 Speech Recognition"):
-            with gr.Row():
-                asr_input = gr.Audio(sources=["upload", "microphone"], type="numpy")
-                asr_output = gr.Textbox(label="Transcription", lines=3)
-            asr_btn = gr.Button("Transcribe")
-            asr_btn.click(speech_recognition, asr_input, asr_output)
-        
-        # Chat
-        with gr.TabItem("💬 Chat"):
-            with gr.Row():
-                chat_input = gr.Textbox(
-                    label="Messages (JSON)", 
-                    lines=3,
-                    value='[{"role":"user","content":"What is machine learning?"}]'
-                )
-                chat_output = gr.Textbox(label="Response", lines=5)
-            chat_btn = gr.Button("Send")
-            chat_btn.click(chat_completion, chat_input, chat_output)
-        
-        # Fill Mask
-        with gr.TabItem("🎭 Fill Mask"):
-            with gr.Row():
-                mask_input = gr.Textbox(
-                    label="Text with [MASK]",
-                    value="The capital of France is [MASK]."
-                )
-                mask_output = gr.Textbox(label="Predictions", lines=5)
-            mask_btn = gr.Button("Predict")
-            mask_btn.click(fill_mask, mask_input, mask_output)
-        
-        # Q&A
-        with gr.TabItem("❓ Q&A"):
-            with gr.Column():
-                qa_question = gr.Textbox(label="Question", value="What is AI?")
-                qa_context = gr.Textbox(
-                    label="Context", 
-                    lines=3,
-                    value="Artificial Intelligence (AI) is the simulation of human intelligence in machines."
-                )
-                qa_output = gr.Textbox(label="Answer", lines=3)
-            qa_btn = gr.Button("Answer")
-            qa_btn.click(question_answering, [qa_question, qa_context], qa_output)
-        
-        # Summarization
-        with gr.TabItem("📝 Summarization"):
-            with gr.Row():
-                sum_input = gr.Textbox(
-                    label="Text to Summarize",
-                    lines=5,
-                    value="Machine learning is a method of data analysis that automates analytical model building. It is a branch of artificial intelligence based on the idea that systems can learn from data, identify patterns and make decisions with minimal human intervention."
-                )
-                sum_output = gr.Textbox(label="Summary", lines=3)
-            sum_btn = gr.Button("Summarize")
-            sum_btn.click(summarization, sum_input, sum_output)
-        
-        # Text Generation
-        with gr.TabItem("✍️ Text Generation"):
-            with gr.Row():
-                gen_input = gr.Textbox(
-                    label="Prompt",
-                    value="The future of AI research will be"
-                )
-                gen_output = gr.Textbox(label="Generated Text", lines=5)
-            gen_btn = gr.Button("Generate")
-            gen_btn.click(text_generation, gen_input, gen_output)
-        
-        # Image Classification
-        with gr.TabItem("🖼️ Image Classification"):
-            with gr.Row():
-                img_input = gr.Image(type="filepath")
-                img_output = gr.Textbox(label="Classification", lines=5)
-            img_btn = gr.Button("Classify")
-            img_btn.click(image_classification, img_input, img_output)
-        
-        # Feature Extraction
-        with gr.TabItem("🧮 Feature Extraction"):
-            with gr.Row():
-                fe_input = gr.Textbox(
-                    label="Text",
-                    value="This is a sample text for feature extraction."
-                )
-                fe_output = gr.Textbox(label="Features", lines=5)
-            fe_btn = gr.Button("Extract")
-            fe_btn.click(feature_extraction, fe_input, fe_output)
+        gr.Markdown("❌ **Status:** Set HF_API_TOKEN environment variable")
+    
+    # Chat Tab
+    gr.Markdown("## 💬 Chat with AI")
+    chat_input = gr.Textbox(label="Your Message", placeholder="Ask anything...")
+    chat_output = gr.Textbox(label="AI Response", lines=5)
+    chat_btn = gr.Button("Send", variant="primary")
+    chat_btn.click(run_chat, inputs=chat_input, outputs=chat_output)
+    
+    gr.Markdown("---")
+    
+    # Fill Mask
+    gr.Markdown("## 🎭 Fill Mask")
+    mask_input = gr.Textbox(
+        label="Text with [MASK]", 
+        value="The capital of France is [MASK].",
+        placeholder="Enter text with [MASK] token"
+    )
+    mask_output = gr.Textbox(label="Predictions", lines=6)
+    mask_btn = gr.Button("Predict", variant="primary")
+    mask_btn.click(run_fill_mask, inputs=mask_input, outputs=mask_output)
+    
+    gr.Markdown("---")
+    
+    # Q&A
+    gr.Markdown("## ❓ Question Answering")
+    qa_question = gr.Textbox(label="Question", value="What is AI?")
+    qa_context = gr.Textbox(
+        label="Context", 
+        lines=3,
+        value="Artificial Intelligence (AI) is the simulation of human intelligence in machines."
+    )
+    qa_output = gr.Textbox(label="Answer", lines=3)
+    qa_btn = gr.Button("Answer", variant="primary")
+    qa_btn.click(run_question_answering, inputs=[qa_question, qa_context], outputs=qa_output)
+    
+    gr.Markdown("---")
+    
+    # Summarization
+    gr.Markdown("## 📝 Text Summarization")
+    sum_input = gr.Textbox(
+        label="Text to Summarize",
+        lines=5,
+        value="Machine learning is a method of data analysis that automates analytical model building. It is a branch of artificial intelligence based on the idea that systems can learn from data, identify patterns and make decisions with minimal human intervention. The process involves feeding data into algorithms that learn patterns and make predictions or decisions without being explicitly programmed for each specific task."
+    )
+    sum_output = gr.Textbox(label="Summary", lines=3)
+    sum_btn = gr.Button("Summarize", variant="primary")
+    sum_btn.click(run_summarization, inputs=sum_input, outputs=sum_output)
+    
+    gr.Markdown("---")
+    gr.Markdown("**🔧 Setup:** `export HF_API_TOKEN=your_token_here`")
 
 if __name__ == "__main__":
     demo.launch(