Upload folder using huggingface_hub

app.py

@@ -1,10 +1,8 @@
 import gradio as gr
 import requests
 import json
-import os
 from typing import Optional
 import base64
-import tempfile
 
 API_BASE_URL = "https://api.mixpeek.com/v1"
 
@@ -37,89 +35,139 @@ def extract_features(
     file: Optional[str],
     text_input: str,
     input_type: str,
-    split_method: str,
-    enable_transcription: bool,
+    model_choice: str,
     enable_embed: bool,
-    enable_ocr: bool,
-    enable_description: bool,
-    enable_thumbnail: bool,
-    interval_sec: int,
+    enable_transcription: bool,
 ) -> str:
     """Extract features from the input using Mixpeek API."""
 
     if not api_key:
         return json.dumps({"error": "Please provide your Mixpeek API key"}, indent=2)
 
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json",
-    }
+    results = {}
 
-    # Build the request payload
-    payload = {
-        "type": "multimodal_extractor_v1",
-        "settings": {}
-    }
+    try:
+        # Handle text input
+        if input_type == "Text":
+            if not text_input.strip():
+                return json.dumps({"error": "Please provide text input"}, indent=2)
+
+            if enable_embed:
+                headers = {
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json",
+                }
+
+                # Map model choice to provider/model
+                model_map = {
+                    "Google Multimodal (1408D)": ("google", "multimodalembedding@001"),
+                    "OpenAI text-embedding-3-large": ("openai", "text-embedding-3-large"),
+                    "OpenAI text-embedding-3-small": ("openai", "text-embedding-3-small"),
+                }
+                provider, model = model_map.get(model_choice, ("google", "multimodalembedding@001"))
+
+                payload = {
+                    "provider": provider,
+                    "model": model,
+                    "inputs": {"text": text_input},
+                    "parameters": {}
+                }
+
+                response = requests.post(
+                    f"{API_BASE_URL}/inference",
+                    headers=headers,
+                    json=payload,
+                    timeout=120
+                )
 
-    # Handle different input types
-    if input_type == "Text":
-        if not text_input.strip():
-            return json.dumps({"error": "Please provide text input"}, indent=2)
-        payload["input"] = {"type": "text", "value": text_input}
-    else:
-        if not file:
-            return json.dumps({"error": "Please upload a file"}, indent=2)
-
-        # Determine the input type from file
-        mime_type = get_file_mime_type(file)
-        base64_data = encode_file_to_base64(file)
-
-        if mime_type.startswith("video"):
-            payload["input"] = {
-                "type": "video",
-                "value": f"data:{mime_type};base64,{base64_data}"
-            }
-            # Video-specific settings
-            payload["settings"]["split"] = {
-                "method": split_method.lower(),
-            }
-            if split_method.lower() == "time":
-                payload["settings"]["split"]["interval_sec"] = interval_sec
+                if response.status_code == 200:
+                    results["embedding"] = response.json()
+                else:
+                    results["embedding_error"] = {
+                        "status": response.status_code,
+                        "details": response.text
+                    }
 
-        elif mime_type == "image/gif":
-            payload["input"] = {
-                "type": "gif",
-                "value": f"data:{mime_type};base64,{base64_data}"
-            }
+            results["input_type"] = "text"
+            results["text"] = text_input
+
+        # Handle file input
         else:
-            payload["input"] = {
-                "type": "image",
-                "value": f"data:{mime_type};base64,{base64_data}"
+            if not file:
+                return json.dumps({"error": "Please upload a file"}, indent=2)
+
+            mime_type = get_file_mime_type(file)
+            base64_data = encode_file_to_base64(file)
+
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
             }
 
-    # Feature toggles
-    payload["settings"]["transcription"] = {"enabled": enable_transcription}
-    payload["settings"]["embed"] = {"enabled": enable_embed}
-    payload["settings"]["ocr"] = {"enabled": enable_ocr}
-    payload["settings"]["describe"] = {"enabled": enable_description}
-    payload["settings"]["thumbnail"] = {"enabled": enable_thumbnail}
+            results["input_type"] = "image" if mime_type.startswith("image") else "video"
+            results["mime_type"] = mime_type
+
+            if enable_embed:
+                # Map model choice
+                model_map = {
+                    "Google Multimodal (1408D)": ("google", "multimodalembedding@001"),
+                    "OpenAI text-embedding-3-large": ("openai", "text-embedding-3-large"),
+                    "OpenAI text-embedding-3-small": ("openai", "text-embedding-3-small"),
+                }
+                provider, model = model_map.get(model_choice, ("google", "multimodalembedding@001"))
+
+                payload = {
+                    "provider": provider,
+                    "model": model,
+                    "inputs": {},
+                    "parameters": {}
+                }
+
+                if mime_type.startswith("image"):
+                    payload["inputs"]["image"] = f"data:{mime_type};base64,{base64_data}"
+                else:
+                    payload["inputs"]["video"] = f"data:{mime_type};base64,{base64_data}"
+
+                response = requests.post(
+                    f"{API_BASE_URL}/inference",
+                    headers=headers,
+                    json=payload,
+                    timeout=180
+                )
 
-    try:
-        response = requests.post(
-            f"{API_BASE_URL}/collections/features/extract",
-            headers=headers,
-            json=payload,
-            timeout=120
-        )
-
-        if response.status_code == 200:
-            result = response.json()
-            return json.dumps(result, indent=2)
-        else:
-            return json.dumps({
-                "error": f"API returned status {response.status_code}",
-                "details": response.text
-            }, indent=2)
+                if response.status_code == 200:
+                    results["embedding"] = response.json()
+                else:
+                    results["embedding_error"] = {
+                        "status": response.status_code,
+                        "details": response.text
+                    }
+
+            # Transcription for video/audio
+            if enable_transcription and (mime_type.startswith("video") or mime_type.startswith("audio")):
+                payload = {
+                    "provider": "openai",
+                    "model": "whisper-1",
+                    "inputs": {"audio": f"data:{mime_type};base64,{base64_data}"},
+                    "parameters": {}
+                }
+
+                response = requests.post(
+                    f"{API_BASE_URL}/inference",
+                    headers=headers,
+                    json=payload,
+                    timeout=180
+                )
+
+                if response.status_code == 200:
+                    results["transcription"] = response.json()
+                else:
+                    results["transcription_error"] = {
+                        "status": response.status_code,
+                        "details": response.text
+                    }
+
+        return json.dumps(results, indent=2)
 
     except requests.exceptions.Timeout:
         return json.dumps({"error": "Request timed out. Try a smaller file."}, indent=2)
@@ -136,16 +184,14 @@ with gr.Blocks(
     # 🎯 Mixpeek Multimodal Feature Extractor
 
     Extract embeddings and features from **videos**, **images**, **GIFs**, and **text** using
-    [Mixpeek's](https://mixpeek.com) multimodal AI pipeline.
+    [Mixpeek's](https://mixpeek.com) inference API.
 
     **Features:**
-    - 🎬 Video decomposition (time, scene, or silence-based splitting)
-    - 🖼️ Image & GIF processing
+    - 🖼️ Image embedding (JPG, PNG, WebP, BMP, GIF)
+    - 🎬 Video embedding (MP4, MOV, AVI, MKV, WebM)
     - 📝 Text embedding
-    - 🎤 Transcription (Whisper)
-    - 👁️ OCR text extraction
-    - 📸 Thumbnail generation
-    - 🔢 1408D multimodal embeddings (Google Vertex AI)
+    - 🎤 Audio transcription (Whisper)
+    - 🔢 Multiple embedding models available
 
     ---
     """)
@@ -178,43 +224,26 @@ with gr.Blocks(
                 visible=False,
             )
 
-            gr.Markdown("### ⚙️ Extraction Settings")
-
-            with gr.Accordion("Video Settings", open=False):
-                split_method = gr.Dropdown(
-                    choices=["Time", "Scene", "Silence"],
-                    value="Time",
-                    label="Split Method",
-                    info="How to segment videos"
-                )
-                interval_sec = gr.Slider(
-                    minimum=1,
-                    maximum=60,
-                    value=10,
-                    step=1,
-                    label="Time Interval (seconds)",
-                    info="For time-based splitting"
-                )
+            gr.Markdown("### ⚙️ Settings")
+
+            model_choice = gr.Dropdown(
+                choices=[
+                    "Google Multimodal (1408D)",
+                    "OpenAI text-embedding-3-large",
+                    "OpenAI text-embedding-3-small",
+                ],
+                value="Google Multimodal (1408D)",
+                label="Embedding Model",
+                info="Select the embedding model to use"
+            )
 
-            with gr.Accordion("Feature Toggles", open=True):
+            with gr.Row():
                 enable_embed = gr.Checkbox(
-                    label="Generate Embeddings (1408D)",
+                    label="Generate Embeddings",
                     value=True,
                 )
                 enable_transcription = gr.Checkbox(
-                    label="Transcription (Whisper)",
-                    value=True,
-                )
-                enable_ocr = gr.Checkbox(
-                    label="OCR Text Extraction",
-                    value=False,
-                )
-                enable_description = gr.Checkbox(
-                    label="AI Description",
-                    value=False,
-                )
-                enable_thumbnail = gr.Checkbox(
-                    label="Generate Thumbnail",
+                    label="Transcription (video/audio only)",
                     value=False,
                 )
 
@@ -248,13 +277,9 @@ with gr.Blocks(
             file_input,
             text_input,
             input_type,
-            split_method,
-            enable_transcription,
+            model_choice,
             enable_embed,
-            enable_ocr,
-            enable_description,
-            enable_thumbnail,
-            interval_sec,
+            enable_transcription,
         ],
         outputs=[output],
     )
@@ -267,13 +292,10 @@ with gr.Blocks(
     - [Get API Key](https://mixpeek.com)
 
     ### 📊 Output Schema
-    Each extracted segment contains:
-    - `start_time` / `end_time` - Timing in seconds (for video/GIF)
-    - `transcription` - Speech-to-text output
-    - `embedding` - 1408D multimodal vector
-    - `ocr_text` - Extracted text from frames
-    - `description` - AI-generated description
-    - `thumbnail_url` - Preview image URL
+    Results contain:
+    - `input_type` - Type of input processed (text/image/video)
+    - `embedding` - Vector embedding from selected model
+    - `transcription` - Speech-to-text output (for video/audio)
     """)
 
 if __name__ == "__main__":