apply pre-commit

README.md

@@ -10,4 +10,4 @@ pinned: false
 disable_embedding: true
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,34 +1,32 @@
-from utils import get_app
-
+from app_allenai import demo as demo_allenai
+from app_claude import demo as demo_claude
 
 # Import all demos
 from app_cohere import demo as demo_cohere
-from app_meta import demo as demo_meta
-from app_lumaai import demo as demo_lumaai
-from app_paligemma import demo as demo_paligemma
-from app_replicate import demo as demo_replicate
-from app_huggingface import demo as demo_huggingface
-from app_playai import demo as demo_playai
-from app_allenai import demo as demo_allenai
-from app_claude import demo as demo_claude
 from app_experimental import demo as demo_experimental
+from app_fal import demo as demo_fal
 from app_fireworks import demo as demo_fireworks
 from app_gemini import demo as demo_gemini
+from app_gemini_voice import demo as demo_gemini_voice
 from app_groq import demo as demo_groq
+from app_huggingface import demo as demo_huggingface
 from app_hyperbolic import demo as demo_hyperbolic
-from app_fal import demo as demo_fal
+from app_lumaai import demo as demo_lumaai
+from app_meta import demo as demo_meta
 from app_mistral import demo as demo_mistral
 from app_nvidia import demo as demo_nvidia
+from app_omini import demo as demo_omini
 from app_openai import demo as demo_openai
+from app_paligemma import demo as demo_paligemma
 from app_perplexity import demo as demo_perplexity
+from app_playai import demo as demo_playai
 from app_qwen import demo as demo_qwen
+from app_replicate import demo as demo_replicate
 from app_sambanova import demo as demo_sambanova
+from app_showui import demo as demo_showui
 from app_together import demo as demo_together
 from app_xai import demo as demo_grok
-from app_showui import demo as demo_showui
-from app_omini import demo as demo_omini
-from app_gemini_voice import demo as demo_gemini_voice
-
+from utils import get_app
 
 # Create mapping of providers to their demos
 PROVIDERS = {
@@ -57,19 +55,12 @@ PROVIDERS = {
     "Perplexity": demo_perplexity,
     "Experimental": demo_experimental,
     "Mistral": demo_mistral,
-    "NVIDIA": demo_nvidia
+    "NVIDIA": demo_nvidia,
 }
 
-demo = get_app(
-    models=list(PROVIDERS.keys()),
-    default_model="Gemini",
-    src=PROVIDERS,
-    dropdown_label="Select Provider"
-)
+demo = get_app(models=list(PROVIDERS.keys()), default_model="Gemini", src=PROVIDERS, dropdown_label="Select Provider")
 
 if __name__ == "__main__":
     demo.queue(
         api_open=False,
-    ).launch(
-        show_api=False
-    )
+    ).launch(show_api=False)

app_allenai.py

@@ -1,10 +1,8 @@
-from gradio_client import Client
 import gradio as gr
+from gradio_client import Client
+
+MODELS = {"OLMo-2-1124-13B-Instruct": "akhaliq/olmo-anychat", "Llama-3.1-Tulu-3-8B": "akhaliq/allen-test"}
 
-MODELS = {
-    "OLMo-2-1124-13B-Instruct": "akhaliq/olmo-anychat",
-    "Llama-3.1-Tulu-3-8B": "akhaliq/allen-test"
-}
 
 def create_chat_fn(client):
     def chat(message, history):
@@ -16,51 +14,49 @@ def create_chat_fn(client):
             top_k=40,
             repetition_penalty=1.1,
             top_p=0.95,
-            api_name="/chat"
+            api_name="/chat",
         )
         return response
+
     return chat
 
+
 def set_client_for_session(model_name, request: gr.Request):
     headers = {}
-    if request and hasattr(request, 'request') and hasattr(request.request, 'headers'):
-        x_ip_token = request.request.headers.get('x-ip-token')
+    if request and hasattr(request, "request") and hasattr(request.request, "headers"):
+        x_ip_token = request.request.headers.get("x-ip-token")
         if x_ip_token:
             headers["X-IP-Token"] = x_ip_token
-    
+
     return Client(MODELS[model_name], headers=headers)
 
+
 def safe_chat_fn(message, history, client):
     if client is None:
         return "Error: Client not initialized. Please refresh the page."
     return create_chat_fn(client)(message, history)
 
+
 with gr.Blocks() as demo:
-    
+
     client = gr.State()
-    
+
     model_dropdown = gr.Dropdown(
-        choices=list(MODELS.keys()),
-        value="OLMo-2-1124-13B-Instruct",
-        label="Select Model",
-        interactive=True
-    )
-    
-    chat_interface = gr.ChatInterface(
-        fn=safe_chat_fn,
-        additional_inputs=[client]
+        choices=list(MODELS.keys()), value="OLMo-2-1124-13B-Instruct", label="Select Model", interactive=True
     )
-    
+
+    chat_interface = gr.ChatInterface(fn=safe_chat_fn, additional_inputs=[client])
+
     # Update client when model changes
     def update_model(model_name, request):
         return set_client_for_session(model_name, request)
-    
+
     model_dropdown.change(
         fn=update_model,
         inputs=[model_dropdown],
         outputs=[client],
     )
-    
+
     # Initialize client on page load
     demo.load(
         fn=set_client_for_session,
@@ -69,5 +65,3 @@ with gr.Blocks() as demo:
     )
 
 demo = demo
-
-

app_cohere.py

@@ -18,4 +18,4 @@ demo = get_app(
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

app_gemini_voice.py

@@ -1,36 +1,41 @@
-import gradio as gr
-from gradio_webrtc import WebRTC, StreamHandler, get_twilio_turn_credentials
-import websockets.sync.client
-import numpy as np
-import json
 import base64
+import json
 import os
+
+import gradio as gr
+import numpy as np
+import websockets.sync.client
 from dotenv import load_dotenv
+from gradio_webrtc import StreamHandler, WebRTC, get_twilio_turn_credentials
+
 
 class GeminiConfig:
     def __init__(self):
         load_dotenv()
         self.api_key = self._get_api_key()
-        self.host = 'generativelanguage.googleapis.com'
-        self.model = 'models/gemini-2.0-flash-exp'
-        self.ws_url = f'wss://{self.host}/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContent?key={self.api_key}'
+        self.host = "generativelanguage.googleapis.com"
+        self.model = "models/gemini-2.0-flash-exp"
+        self.ws_url = f"wss://{self.host}/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContent?key={self.api_key}"
 
     def _get_api_key(self):
-        api_key = os.getenv('GOOGLE_API_KEY')
+        api_key = os.getenv("GOOGLE_API_KEY")
         if not api_key:
             raise ValueError("GOOGLE_API_KEY not found in environment variables. Please set it in your .env file.")
         return api_key
 
+
 class AudioProcessor:
     @staticmethod
     def encode_audio(data, sample_rate):
-        encoded = base64.b64encode(data.tobytes()).decode('UTF-8')
+        encoded = base64.b64encode(data.tobytes()).decode("UTF-8")
         return {
-            'realtimeInput': {
-                'mediaChunks': [{
-                    'mimeType': f'audio/pcm;rate={sample_rate}',
-                    'data': encoded,
-                }],
+            "realtimeInput": {
+                "mediaChunks": [
+                    {
+                        "mimeType": f"audio/pcm;rate={sample_rate}",
+                        "data": encoded,
+                    }
+                ],
             },
         }
 
@@ -39,13 +44,10 @@ class AudioProcessor:
         audio_data = base64.b64decode(data)
         return np.frombuffer(audio_data, dtype=np.int16)
 
+
 class GeminiHandler(StreamHandler):
-    def __init__(self,
-                 expected_layout="mono",
-                 output_sample_rate=24000,
-                 output_frame_size=480) -> None:
-        super().__init__(expected_layout, output_sample_rate, output_frame_size,
-                        input_sample_rate=24000)
+    def __init__(self, expected_layout="mono", output_sample_rate=24000, output_frame_size=480) -> None:
+        super().__init__(expected_layout, output_sample_rate, output_frame_size, input_sample_rate=24000)
         self.config = GeminiConfig()
         self.ws = None
         self.all_output_data = None
@@ -55,18 +57,15 @@ class GeminiHandler(StreamHandler):
         return GeminiHandler(
             expected_layout=self.expected_layout,
             output_sample_rate=self.output_sample_rate,
-            output_frame_size=self.output_frame_size
+            output_frame_size=self.output_frame_size,
         )
 
     def _initialize_websocket(self):
         try:
-            self.ws = websockets.sync.client.connect(
-                self.config.ws_url,
-                timeout=30
-            )
+            self.ws = websockets.sync.client.connect(self.config.ws_url, timeout=30)
             initial_request = {
-                'setup': {
-                    'model': self.config.model,
+                "setup": {
+                    "model": self.config.model,
                 }
             }
             self.ws.send(json.dumps(initial_request))
@@ -87,7 +86,7 @@ class GeminiHandler(StreamHandler):
             _, array = frame
             array = array.squeeze()
             audio_message = self.audio_processor.encode_audio(array, self.output_sample_rate)
-            self.ws.send(json.dumps(audio_message))
+            self.ws.send(json.dumps(audio_message))  # type: ignore
         except Exception as e:
             print(f"Error in receive: {str(e)}")
             if self.ws:
@@ -95,8 +94,8 @@ class GeminiHandler(StreamHandler):
             self.ws = None
 
     def _process_server_content(self, content):
-        for part in content.get('parts', []):
-            data = part.get('inlineData', {}).get('data', '')
+        for part in content.get("parts", []):
+            data = part.get("inlineData", {}).get("data", "")
             if data:
                 audio_array = self.audio_processor.process_audio_response(data)
                 if self.all_output_data is None:
@@ -105,9 +104,8 @@ class GeminiHandler(StreamHandler):
                     self.all_output_data = np.concatenate((self.all_output_data, audio_array))
 
                 while self.all_output_data.shape[-1] >= self.output_frame_size:
-                    yield (self.output_sample_rate,
-                          self.all_output_data[:self.output_frame_size].reshape(1, -1))
-                    self.all_output_data = self.all_output_data[self.output_frame_size:]
+                    yield (self.output_sample_rate, self.all_output_data[: self.output_frame_size].reshape(1, -1))
+                    self.all_output_data = self.all_output_data[self.output_frame_size :]
 
     def generator(self):
         while True:
@@ -120,8 +118,8 @@ class GeminiHandler(StreamHandler):
                 message = self.ws.recv(timeout=5)
                 msg = json.loads(message)
 
-                if 'serverContent' in msg:
-                    content = msg['serverContent'].get('modelTurn', {})
+                if "serverContent" in msg:
+                    content = msg["serverContent"].get("modelTurn", {})
                     yield from self._process_server_content(content)
             except TimeoutError:
                 print("Timeout waiting for server response")
@@ -133,7 +131,7 @@ class GeminiHandler(StreamHandler):
     def emit(self) -> tuple[int, np.ndarray] | None:
         if not self.ws:
             return None
-        if not hasattr(self, '_generator'):
+        if not hasattr(self, "_generator"):
             self._generator = self.generator()
         try:
             return next(self._generator)
@@ -142,8 +140,8 @@ class GeminiHandler(StreamHandler):
             return None
 
     def reset(self) -> None:
-        if hasattr(self, '_generator'):
-            delattr(self, '_generator')
+        if hasattr(self, "_generator"):
+            delattr(self, "_generator")
         self.all_output_data = None
 
     def shutdown(self) -> None:
@@ -159,6 +157,7 @@ class GeminiHandler(StreamHandler):
             print(f"Connection check failed: {str(e)}")
             return False
 
+
 class GeminiVoiceChat:
     def __init__(self):
         load_dotenv()
@@ -166,38 +165,30 @@ class GeminiVoiceChat:
 
     def _create_interface(self):
         with gr.Blocks() as demo:
-            gr.HTML("""
+            gr.HTML(
+                """
                 <div style='text-align: center'>
                     <h1>Gemini 2.0 Voice Chat</h1>
                     <p>Speak with Gemini using real-time audio streaming</p>
                 </div>
-            """)
+            """
+            )
 
             webrtc = WebRTC(
                 label="Conversation",
                 modality="audio",
                 mode="send-receive",
-                rtc_configuration=get_twilio_turn_credentials()
+                rtc_configuration=get_twilio_turn_credentials(),
             )
 
-            webrtc.stream(
-                GeminiHandler(),
-                inputs=[webrtc],
-                outputs=[webrtc],
-                time_limit=90,
-                concurrency_limit=10
-            )
+            webrtc.stream(GeminiHandler(), inputs=[webrtc], outputs=[webrtc], time_limit=90, concurrency_limit=10)
         return demo
 
     def launch(self):
         self.demo.launch()
-# Create and expose the demo instance
-def demo():
-    chat = GeminiVoiceChat()
-    return chat.demo
 
-# This is what will be imported by app.py
-demo = demo()
+
+demo = GeminiVoiceChat().demo
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0")

app_huggingface.py

@@ -1,21 +1,18 @@
-from gradio_client import Client, handle_file
 import gradio as gr
-import os
+from gradio_client import Client, handle_file
 
+MODELS = {"SmolVLM-Instruct": "akhaliq/SmolVLM-Instruct"}
 
-MODELS = {
-    "SmolVLM-Instruct": "akhaliq/SmolVLM-Instruct"
-}
 
 def create_chat_fn(client):
     def chat(message, history):
         # Extract text and files from the message
         text = message.get("text", "")
         files = message.get("files", [])
-        
+
         # Handle file uploads if present
         processed_files = [handle_file(f) for f in files]
-        
+
         response = client.predict(
             message={"text": text, "files": processed_files},
             system_prompt="You are a helpful AI assistant.",
@@ -24,20 +21,23 @@ def create_chat_fn(client):
             top_k=40,
             repetition_penalty=1.1,
             top_p=0.95,
-            api_name="/chat"
+            api_name="/chat",
         )
         return response
+
     return chat
 
+
 def set_client_for_session(model_name, request: gr.Request):
     headers = {}
-    if request and hasattr(request, 'headers'):
-        x_ip_token = request.headers.get('x-ip-token')
+    if request and hasattr(request, "headers"):
+        x_ip_token = request.headers.get("x-ip-token")
         if x_ip_token:
             headers["X-IP-Token"] = x_ip_token
-    
+
     return Client(MODELS[model_name], headers=headers)
 
+
 def safe_chat_fn(message, history, client):
     if client is None:
         return "Error: Client not initialized. Please refresh the page."
@@ -47,36 +47,22 @@ def safe_chat_fn(message, history, client):
         print(f"Error during chat: {str(e)}")
         return f"Error during chat: {str(e)}"
 
+
 with gr.Blocks() as demo:
-    
+
     client = gr.State()
-    
+
     model_dropdown = gr.Dropdown(
-        choices=list(MODELS.keys()),
-        value="SmolVLM-Instruct",
-        label="Select Model",
-        interactive=True
-    )
-    
-    chat_interface = gr.ChatInterface(
-        fn=safe_chat_fn,
-        additional_inputs=[client],
-        multimodal=True
+        choices=list(MODELS.keys()), value="SmolVLM-Instruct", label="Select Model", interactive=True
     )
-    
+
+    chat_interface = gr.ChatInterface(fn=safe_chat_fn, additional_inputs=[client], multimodal=True)
+
     # Update client when model changes
-    model_dropdown.change(
-        fn=set_client_for_session,
-        inputs=[model_dropdown],
-        outputs=[client]
-    )
-    
-    # Initialize client on page load
-    demo.load(
-        fn=set_client_for_session,
-        inputs=[gr.State("SmolVLM-Instruct")],
-        outputs=[client]
-    )
+    model_dropdown.change(fn=set_client_for_session, inputs=[model_dropdown], outputs=[client])
 
-demo = demo
+    # Initialize client on page load
+    demo.load(fn=set_client_for_session, inputs=[gr.State("SmolVLM-Instruct")], outputs=[client])
 
+if __name__ == "__main__":
+    demo.launch()

app_lumaai.py

@@ -2,6 +2,6 @@ import gradio as gr
 import lumaai_gradio
 
 demo = gr.load(
-    name='dream-machine',
+    name="dream-machine",
     src=lumaai_gradio.registry,
-)
+)

app_meta.py

@@ -2,4 +2,4 @@ import gradio as gr
 
 demo = gr.load("models/meta-llama/Llama-3.3-70B-Instruct")
 
-demo = demo
+demo = demo

app_mindsearch.py

@@ -4,9 +4,9 @@ import gradio as gr
 demo = gr.load(name="internlm/MindSearch", src="spaces")
 
 # Disable API access for all functions
-if hasattr(demo, 'fns'):
+if hasattr(demo, "fns"):
     for fn in demo.fns.values():
         fn.api_name = False
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

app_paligemma.py

@@ -1,17 +1,15 @@
-from gradio_client import Client, handle_file
 import gradio as gr
-import os
+from gradio_client import Client, handle_file
+
+MODELS = {"Paligemma-10B": "akhaliq/paligemma2-10b-ft-docci-448"}
 
-MODELS = {
-    "Paligemma-10B": "akhaliq/paligemma2-10b-ft-docci-448"
-}
 
 def create_chat_fn(client, system_prompt, temperature, max_tokens, top_k, rep_penalty, top_p):
     def chat(message, history):
         text = message.get("text", "")
         files = message.get("files", [])
         processed_files = [handle_file(f) for f in files]
-        
+
         response = client.predict(
             message={"text": text, "files": processed_files},
             system_prompt=system_prompt,
@@ -20,79 +18,61 @@ def create_chat_fn(client, system_prompt, temperature, max_tokens, top_k, rep_pe
             top_k=top_k,
             repetition_penalty=rep_penalty,
             top_p=top_p,
-            api_name="/chat"
+            api_name="/chat",
         )
         return response
+
     return chat
 
+
 def set_client_for_session(model_name, request: gr.Request):
     headers = {}
-    if request and hasattr(request, 'headers'):
-        x_ip_token = request.headers.get('x-ip-token')
+    if request and hasattr(request, "headers"):
+        x_ip_token = request.headers.get("x-ip-token")
         if x_ip_token:
             headers["X-IP-Token"] = x_ip_token
-    
+
     return Client(MODELS[model_name], headers=headers)
 
-def safe_chat_fn(message, history, client, system_prompt, temperature, 
-                 max_tokens, top_k, rep_penalty, top_p):
+
+def safe_chat_fn(message, history, client, system_prompt, temperature, max_tokens, top_k, rep_penalty, top_p):
     if client is None:
         return "Error: Client not initialized. Please refresh the page."
     try:
-        return create_chat_fn(client, system_prompt, temperature, 
-                            max_tokens, top_k, rep_penalty, top_p)(message, history)
+        return create_chat_fn(client, system_prompt, temperature, max_tokens, top_k, rep_penalty, top_p)(
+            message, history
+        )
     except Exception as e:
         print(f"Error during chat: {str(e)}")
         return f"Error during chat: {str(e)}"
 
+
 with gr.Blocks() as demo:
     client = gr.State()
-    
+
     with gr.Accordion("Advanced Settings", open=False):
-        system_prompt = gr.Textbox(
-            value="You are a helpful AI assistant.",
-            label="System Prompt"
-        )
+        system_prompt = gr.Textbox(value="You are a helpful AI assistant.", label="System Prompt")
         with gr.Row():
-            temperature = gr.Slider(
-                minimum=0.0, maximum=2.0, value=0.7,
-                label="Temperature"
-            )
-            top_p = gr.Slider(
-                minimum=0.0, maximum=1.0, value=0.95,
-                label="Top P"
-            )
+            temperature = gr.Slider(minimum=0.0, maximum=2.0, value=0.7, label="Temperature")
+            top_p = gr.Slider(minimum=0.0, maximum=1.0, value=0.95, label="Top P")
         with gr.Row():
-            top_k = gr.Slider(
-                minimum=1, maximum=100, value=40, step=1,
-                label="Top K"
-            )
-            rep_penalty = gr.Slider(
-                minimum=1.0, maximum=2.0, value=1.1,
-                label="Repetition Penalty"
-            )
-        max_tokens = gr.Slider(
-            minimum=64, maximum=4096, value=1024, step=64,
-            label="Max Tokens"
-        )
-    
+            top_k = gr.Slider(minimum=1, maximum=100, value=40, step=1, label="Top K")
+            rep_penalty = gr.Slider(minimum=1.0, maximum=2.0, value=1.1, label="Repetition Penalty")
+        max_tokens = gr.Slider(minimum=64, maximum=4096, value=1024, step=64, label="Max Tokens")
+
     chat_interface = gr.ChatInterface(
         fn=safe_chat_fn,
-        additional_inputs=[client, system_prompt, temperature, 
-                         max_tokens, top_k, rep_penalty, top_p],
-        multimodal=True
+        additional_inputs=[client, system_prompt, temperature, max_tokens, top_k, rep_penalty, top_p],
+        multimodal=True,
     )
-    
+
     # Initialize client on page load with default model
-    demo.load(
-        fn=set_client_for_session,
-        inputs=[gr.State("Paligemma-10B")],  # Using default model
-        outputs=[client]
-    )
+    demo.load(fn=set_client_for_session, inputs=[gr.State("Paligemma-10B")], outputs=[client])  # Using default model
 
 # Move the API access check here, after demo is defined
-if hasattr(demo, 'fns'):
+if hasattr(demo, "fns"):
     for fn in demo.fns.values():
         fn.api_name = False
 
-demo = demo
+if __name__ == "__main__":
+    demo.launch()

app_playai.py

@@ -1,10 +1,10 @@
 import gradio as gr
 import playai_gradio
 
-demo =gr.load(
-    name='PlayDialog',
+demo = gr.load(
+    name="PlayDialog",
     src=playai_gradio.registry,
 )
 
 for fn in demo.fns.values():
-    fn.api_name = False
+    fn.api_name = False

app_showui.py

@@ -5,6 +5,6 @@ demo = gr.load(name="showlab/ShowUI", src="spaces")
 
 
 # Disable API access for all functions
-if hasattr(demo, 'fns'):
+if hasattr(demo, "fns"):
     for fn in demo.fns.values():
         fn.api_name = False

app_trellis.py

@@ -7,4 +7,4 @@ demo = gr.load(name="JeffreyXiang/TRELLIS", src="spaces")
 # Disable API access for all functions
 if hasattr(demo, "fns"):
     for fn in demo.fns.values():
-        fn.api_name = False
+        fn.api_name = False

utils.py

@@ -1,4 +1,4 @@
-from typing import Callable, Literal, Dict, Union
+from typing import Callable, Dict, Literal, Union
 
 import gradio as gr