Create app.py

app.py

@@ -0,0 +1,120 @@
+import gradio as gr
+from huggingface_hub import InferenceClient
+import io
+import json
+import base64
+from PIL import Image
+
+# Initialize the public client
+client = InferenceClient()
+
+def universal_inference(model_id, text_input, image_input, audio_input, custom_json):
+    if not model_id.strip():
+        return "Please enter a valid Hugging Face Model ID.", None, None
+
+    # 1. Determine Input Payload
+    # If custom JSON configuration is provided, use it directly
+    if custom_json.strip():
+        try:
+            payload = json.loads(custom_json)
+        except Exception as e:
+            return f"Invalid Custom JSON Formatting: {str(e)}", None, None
+    
+    # Otherwise, automatically construct standard structure based on provided inputs
+    else:
+        payload = {}
+        if text_input.strip():
+            # Standard formats for LLMs / Text models
+            payload["inputs"] = text_input.strip()
+        
+        if image_input is not None:
+            # Convert image to base64 for vision/multimodal models
+            buffered = io.BytesIO()
+            image_input.save(buffered, format="JPEG")
+            img_b64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
+            
+            if text_input.strip():
+                # VLM / Visual QA format
+                payload = {"inputs": {"image": img_b64, "text": text_input.strip()}}
+            else:
+                # Basic Image-to-Image / Depth-map format
+                payload = {"inputs": img_b64}
+                
+        if audio_input is not None:
+            # Handle audio file path (read binary)
+            with open(audio_input, "rb") as f:
+                audio_bytes = f.read()
+            audio_b64 = base64.b64encode(audio_bytes).decode('utf-8')
+            payload = {"inputs": audio_b64}
+
+    # 2. Execute Request to Hugging Face Serverless API
+    try:
+        # We send raw data via POST to allow the API to return whatever the model creates
+        response = client.post(json=payload, model=model_id)
+        content_type = response.headers.get("content-type", "")
+
+        # 3. Dynamic Output Routing based on API response type
+        # Text Responses (LLM, Translation, Classification, etc.)
+        if "text" in content_type or "json" in content_type:
+            try:
+                parsed_json = response.json()
+                return json.dumps(parsed_json, indent=2), None, None
+            except:
+                return response.text, None, None
+                
+        # Image Responses (Text-to-Image, Inpainting, etc.)
+        elif "image" in content_type:
+            img = Image.open(io.BytesIO(response.content))
+            return "Image successfully generated!", img, None
+            
+        # Audio Responses (TTS, Voice conversion, etc.)
+        elif "audio" in content_type or "octet-stream" in content_type:
+            # Convert bytes straight to tuple layout for Gradio Audio (data_bytes, format)
+            return "Audio successfully generated!", None, response.content
+
+        else:
+            return f"Unknown content return type: {content_type}. Raw data length: {len(response.content)} bytes", None, None
+
+    except Exception as e:
+        return f"Error executing model request:\n{str(e)}\n\n💡 Tip: Verify that the Model ID is typed correctly and is currently active on Hugging Face Serverless API.", None, None
+
+# --- GRADIO INTERFACE ---
+with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
+    gr.Markdown("# 🌐 Universal Zero Chat Any")
+    gr.Markdown("Input **any** model from Hugging Face. The app automatically intercepts the output format (Text, Image, or Audio).")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            model_id = gr.Textbox(
+                label="🎯 Hugging Face Model ID", 
+                value="meta-llama/Llama-3.1-8B-Instruct",
+                placeholder="e.g., stabilityai/stable-diffusion-3-medium, facebook/mms-tts-eng, etc."
+            )
+            
+            gr.Markdown("### Input Fields (Fill out what your target model requires)")
+            text_in = gr.Textbox(label="Text Input / Prompt", lines=3)
+            image_in = gr.Image(type="pil", label="Image Input (Optional)")
+            audio_in = gr.Audio(type="filepath", label="Audio Input (Optional)")
+            
+            with gr.Accordion("⚙️ Advanced: Override with Raw JSON Payload", open=False):
+                custom_json = gr.Textbox(
+                    label="Custom JSON Parameters", 
+                    placeholder='{"inputs": "Your prompt", "parameters": {"temperature": 0.7}}', 
+                    lines=4
+                )
+            
+            submit_btn = gr.Button("🚀 Run Inference", variant="primary")
+            
+        with gr.Column(scale=1):
+            gr.Markdown("### 📥 Model Output Triggers")
+            text_out = gr.Textbox(label="Text Output / Logs", lines=10, interactive=False)
+            image_out = gr.Image(label="Generated Image Output")
+            audio_out = gr.Audio(label="Generated Audio Output")
+
+    submit_btn.click(
+        universal_inference, 
+        inputs=[model_id, text_in, image_in, audio_in, custom_json], 
+        outputs=[text_out, image_out, audio_out]
+    )
+
+demo.launch()