Update app.py

app.py

@@ -1,22 +1,17 @@
 import gradio as gr
 import torch
 import torchaudio
-import scipy.io.wavfile
 import numpy as np
 from transformers import AutoProcessor, SeamlessM4Tv2Model
-from pathlib import Path
-from typing import Optional, Union
+from datetime import datetime
+import time
 
-class SeamlessTranslator:
+class JarvisTranslator:
     def __init__(self, model_name: str = "facebook/seamless-m4t-v2-large"):
-        try:
-            self.processor = AutoProcessor.from_pretrained(model_name)
-            self.model = SeamlessM4Tv2Model.from_pretrained(model_name)
-            self.sample_rate = self.model.config.sampling_rate
-        except Exception as e:
-            raise RuntimeError(f"Failed to initialize model: {str(e)}")
+        self.processor = AutoProcessor.from_pretrained(model_name)
+        self.model = SeamlessM4Tv2Model.from_pretrained(model_name)
+        self.sample_rate = self.model.config.sampling_rate
         
-        # Available language pairs
         self.language_codes = {
             "English": "eng",
             "Spanish": "spa",
@@ -26,130 +21,135 @@ class SeamlessTranslator:
             "Portuguese": "por",
             "Russian": "rus",
             "Chinese": "cmn",
-            "Japanese": "jpn",
-            "Korean": "kor",
-            "Arabic": "ara",
-            "Hindi": "hin",
+            "Japanese": "jpn"
         }
 
-    def translate_text(self, text: str, src_lang: str, tgt_lang: str) -> tuple[int, np.ndarray]:
-        try:
-            inputs = self.processor(text=text, src_lang=src_lang, return_tensors="pt")
-            audio_array = self.model.generate(**inputs, tgt_lang=tgt_lang)[0].cpu().numpy().squeeze()
-            return self.sample_rate, audio_array
-        except Exception as e:
-            raise RuntimeError(f"Text translation failed: {str(e)}")
-
-    def translate_audio(self, audio_path: str, tgt_lang: str) -> tuple[int, np.ndarray]:
-        try:
-            # Load and resample audio
-            audio, orig_freq = torchaudio.load(audio_path)
-            audio = torchaudio.functional.resample(
-                audio, 
-                orig_freq=orig_freq, 
-                new_freq=16_000
-            )
-            
-            # Process and generate translation
-            inputs = self.processor(audios=audio, return_tensors="pt")
-            audio_array = self.model.generate(**inputs, tgt_lang=tgt_lang)[0].cpu().numpy().squeeze()
-            return self.sample_rate, audio_array
-        except Exception as e:
-            raise RuntimeError(f"Audio translation failed: {str(e)}")
-
-class GradioInterface:
-    def __init__(self):
-        self.translator = SeamlessTranslator()
-        self.languages = list(self.translator.language_codes.keys())
-
-    def text_to_speech(self, text: str, src_lang: str, tgt_lang: str) -> tuple[int, np.ndarray]:
-        src_code = self.translator.language_codes[src_lang]
-        tgt_code = self.translator.language_codes[tgt_lang]
-        return self.translator.translate_text(text, src_code, tgt_code)
+    def translate(self, text: str, src_lang: str, tgt_lang: str) -> tuple[int, np.ndarray]:
+        inputs = self.processor(text=text, src_lang=src_lang, return_tensors="pt")
+        audio_array = self.model.generate(**inputs, tgt_lang=tgt_lang)[0].cpu().numpy().squeeze()
+        return self.sample_rate, audio_array
 
-    def speech_to_speech(self, audio_path: str, tgt_lang: str) -> tuple[int, np.ndarray]:
-        tgt_code = self.translator.language_codes[tgt_lang]
-        return self.translator.translate_audio(audio_path, tgt_code)
+def create_jarvis_interface():
+    # Custom CSS for Jarvis-like theme
+    css = """
+    #jarvis-container {
+        background-color: #000000;
+        color: #00ffff;
+        font-family: 'Courier New', monospace;
+        padding: 20px;
+        border-radius: 10px;
+        border: 2px solid #00ffff;
+    }
+    
+    #status-circle {
+        width: 150px;
+        height: 150px;
+        border: 4px solid #00ffff;
+        border-radius: 50%;
+        margin: 20px auto;
+        position: relative;
+        animation: pulse 2s infinite;
+    }
+    
+    @keyframes pulse {
+        0% { box-shadow: 0 0 0 0 rgba(0, 255, 255, 0.4); }
+        70% { box-shadow: 0 0 0 20px rgba(0, 255, 255, 0); }
+        100% { box-shadow: 0 0 0 0 rgba(0, 255, 255, 0); }
+    }
+    
+    .custom-button {
+        background-color: transparent !important;
+        border: 2px solid #00ffff !important;
+        color: #00ffff !important;
+        font-family: 'Courier New', monospace !important;
+    }
+    
+    .custom-button:hover {
+        background-color: rgba(0, 255, 255, 0.1) !important;
+    }
+    
+    .status-text {
+        color: #00ffff;
+        text-align: center;
+        font-size: 1.2em;
+        margin: 10px 0;
+    }
+    
+    .time-display {
+        position: absolute;
+        top: 10px;
+        right: 10px;
+        color: #00ffff;
+        font-family: 'Courier New', monospace;
+    }
+    """
 
-    def launch(self):
-        # Create the Gradio interface
-        with gr.Blocks(title="SeamlessM4T Translator") as demo:
-            gr.Markdown("# 🌐 SeamlessM4T Translator")
-            gr.Markdown("Translate text or speech to different languages using Meta's SeamlessM4T model")
+    translator = JarvisTranslator()
 
-            with gr.Tabs():
-                # Text-to-Speech tab
-                with gr.TabItem("Text to Speech"):
-                    with gr.Row():
-                        with gr.Column():
-                            text_input = gr.Textbox(
-                                label="Input Text",
-                                placeholder="Enter text to translate...",
-                                lines=3
-                            )
-                            src_lang = gr.Dropdown(
-                                choices=self.languages,
-                                value="English",
-                                label="Source Language"
-                            )
-                            tgt_lang_text = gr.Dropdown(
-                                choices=self.languages,
-                                value="Spanish",
-                                label="Target Language"
-                            )
-                            translate_btn = gr.Button("Translate", variant="primary")
-                        
-                        with gr.Column():
-                            audio_output = gr.Audio(
-                                label="Translated Speech",
-                                type="numpy"
-                            )
+    def update_status():
+        return f"JARVIS AI SYSTEM ACTIVE\nTime: {datetime.now().strftime('%H:%M:%S')}"
 
-                    translate_btn.click(
-                        fn=self.text_to_speech,
-                        inputs=[text_input, src_lang, tgt_lang_text],
-                        outputs=audio_output
-                    )
-
-                # Speech-to-Speech tab
-                with gr.TabItem("Speech to Speech"):
-                    with gr.Row():
-                        with gr.Column():
-                            audio_input = gr.Audio(
-                                label="Input Speech",
-                                type="filepath"
-                            )
-                            tgt_lang_speech = gr.Dropdown(
-                                choices=self.languages,
-                                value="Spanish",
-                                label="Target Language"
-                            )
-                            translate_audio_btn = gr.Button("Translate", variant="primary")
-                        
-                        with gr.Column():
-                            audio_output_s2s = gr.Audio(
-                                label="Translated Speech",
-                                type="numpy"
-                            )
-
-                    translate_audio_btn.click(
-                        fn=self.speech_to_speech,
-                        inputs=[audio_input, tgt_lang_speech],
-                        outputs=audio_output_s2s
-                    )
+    def process_command(text, src_lang, tgt_lang):
+        status = f"Processing command: {text}\nSource: {src_lang} → Target: {tgt_lang}"
+        time.sleep(1)  # Simulate processing
+        try:
+            sample_rate, audio = translator.translate(text, 
+                                                    translator.language_codes[src_lang],
+                                                    translator.language_codes[tgt_lang])
+            return audio, status + "\nStatus: Translation complete"
+        except Exception as e:
+            return None, f"Error: {str(e)}"
 
-            gr.Markdown(
-                """
-                ### Notes
-                - Text-to-Speech: Enter text and select source/target languages
-                - Speech-to-Speech: Upload an audio file and select target language
-                - Processing may take a few moments depending on input length
-                """
+    with gr.Blocks(css=css, title="JARVIS AI") as demo:
+        with gr.Column(elem_id="jarvis-container"):
+            gr.Markdown("# JARVIS AI TRANSLATION SYSTEM")
+            
+            # Status display
+            status_html = gr.HTML(value="<div id='status-circle'></div>", show_label=False)
+            status_text = gr.Textbox(label="System Status", value=update_status)
+            
+            with gr.Row():
+                text_input = gr.Textbox(
+                    label="Command Input",
+                    placeholder="Enter text to translate...",
+                    lines=3
+                )
+                
+            with gr.Row():
+                src_lang = gr.Dropdown(
+                    choices=list(translator.language_codes.keys()),
+                    value="English",
+                    label="Source Language"
+                )
+                tgt_lang = gr.Dropdown(
+                    choices=list(translator.language_codes.keys()),
+                    value="Spanish",
+                    label="Target Language"
+                )
+                
+            with gr.Row():
+                process_btn = gr.Button("Execute Translation", elem_classes=["custom-button"])
+                
+            audio_output = gr.Audio(
+                label="Translated Output",
+                type="numpy"
+            )
+            
+            # Event handlers
+            process_btn.click(
+                fn=process_command,
+                inputs=[text_input, src_lang, tgt_lang],
+                outputs=[audio_output, status_text]
+            )
+            
+            demo.load(
+                fn=update_status,
+                outputs=status_text,
+                every=1  # Update every second
             )
 
-        # Launch the interface
-        demo.launch(share=True)
+    return demo
 
 if __name__ == "__main__":
-    interface = GradioInterface()
-    interface.launch()
+    demo = create_jarvis_interface()
+    demo.launch()