Update app.py

app.py

@@ -1,133 +1,20 @@
-import gradio as gr
-import asyncio
 import os
-from duckduckgo_search import DDGS
-import edge_tts
-import hashlib
-from datetime import datetime
-import re
+import tempfile
+import importlib.util
 
-# Hardcoded values
-MODEL = "claude-3-haiku"
-VOICE = "en-US-AriaNeural"
-MAX_WORDS_PER_PART = 30  # Split into chunks of ~30 words for quick generation
-
-async def text_to_speech(text, output_file):
-    """Convert text to speech using edge-tts"""
-    communicate = edge_tts.Communicate(text, VOICE)
-    await communicate.save(output_file)
-    return output_file
-
-def get_chat_response(query):
-    """Get response from DuckDuckGo Chat"""
-    try:
-        system_prompt = "<system_prompt>Your name is Vani. Give short, natural responses under 100 words that sound like casual human speech. Avoid lists, technical jargon, or complex sentences. Keep it simple and friendly for easy text-to-speech conversion.</system_prompt>"
-        enhanced_query = f"{system_prompt}\n\n{query}"
-        response = DDGS().chat(enhanced_query, model=MODEL, timeout=30)
-        return response
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-def split_response(response_text):
-    """Split response into smaller parts for faster TTS"""
-    # Split into sentences first
-    sentences = re.split(r'(?<=[.!?])\s+', response_text.strip())
-    parts = []
-    current_part = []
-    word_count = 0
-
-    for sentence in sentences:
-        words = sentence.split()
-        if word_count + len(words) > MAX_WORDS_PER_PART and current_part:
-            # Start a new part if we exceed the word limit
-            parts.append(" ".join(current_part))
-            current_part = words
-            word_count = len(words)
-        else:
-            current_part.extend(words)
-            word_count += len(words)
-    
-    if current_part:  # Add the last part
-        parts.append(" ".join(current_part))
-    
-    return parts
-
-async def process_chat(query):
-    """Process chat query, split response, and generate audio parts"""
-    if not query:
-        return "Please enter a query.", None
-    
-    # Get chat response
-    response_text = get_chat_response(query)
-    
-    # Split response into parts
-    response_parts = split_response(response_text)
+def load_app():
+    code = os.getenv("OPENAI_API_KEY")
+    if not code:
+        raise RuntimeError("No application code found")
     
-    # Generate unique base filename
-    hash_object = hashlib.md5(query.encode())
-    query_hash = hash_object.hexdigest()[:8]
-    timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
-    base_filename = f"response_{timestamp}_{query_hash}"
+    with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+        f.write(code.encode('utf-8'))
+        tmp_name = f.name
     
-    audio_files = []
-    full_text = ""
-    
-    # Process each part sequentially
-    for i, part in enumerate(response_parts):
-        output_file = f"{base_filename}_part{i}.mp3"
-        audio_file = await text_to_speech(part, output_file)
-        audio_files.append(audio_file)
-        full_text += part + " "  # Rebuild full text for display
-    
-    # Return full text and list of audio files
-    return full_text.strip(), audio_files
-
-def gradio_interface(query):
-    """Gradio interface function"""
-    # Run async function in Gradio
-    response_text, audio_files = asyncio.run(process_chat(query))
-    
-    # Return full text and first audio file (Gradio will display one at a time)
-    # Subsequent parts will be available as separate files
-    return response_text, audio_files[0] if audio_files else None
-
-# Create Gradio interface
-with gr.Blocks(title="Chat to Speech Demo") as demo:
-    gr.Markdown("# Chat to Speech Demo")
-    gr.Markdown("Enter a query and get a fast, natural text and audio response split into parts!")
-    
-    with gr.Row():
-        with gr.Column():
-            query_input = gr.Textbox(label="Your Query", placeholder="Ask anything...")
-            submit_btn = gr.Button("Generate")
-        
-        with gr.Column():
-            text_output = gr.Textbox(label="Response Text")
-            audio_output = gr.Audio(label="Response Audio (First Part)")
-            gr.Markdown("Note: If the response is long, it’s split into parts. Check the Spaces file system for all parts.")
-    
-    # Connect inputs to processing function
-    submit_btn.click(
-        fn=gradio_interface,
-        inputs=[query_input],
-        outputs=[text_output, audio_output]
-    )
-
-# Launch optimized for Hugging Face Spaces
-demo.launch(
-    server_name="0.0.0.0",
-    server_port=7860,
-    share=False  # Set to True if you want public sharing
-)
-
-# Clean up audio files
-def cleanup():
-    for file in os.listdir():
-        if file.startswith("response_") and file.endswith(".mp3"):
-            try:
-                os.remove(file)
-            except:
-                pass
+    spec = importlib.util.spec_from_file_location("hidden_app", tmp_name)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.launch()
 
-import atexit
-atexit.register(cleanup)
+if __name__ == "__main__":
+    load_app()