Update app.py

app.py

@@ -1,219 +1,148 @@
 #!/usr/bin/env python3
 #
-# Copyright (c) 2025, Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
+# Hugging Face Compatible Version
+# This version works with Hugging Face Spaces limitations
 #
 
-import argparse
-import datetime
-import io
-import json
 import os
-import sys
-import wave
-
-import aiofiles
+import json
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
 import uvicorn
-from dotenv import load_dotenv
-from fastapi import FastAPI, WebSocket
-from fastapi.middleware.cors import CORSMiddleware
-from loguru import logger
-
-from pipecat.audio.vad.silero import SileroVADAnalyzer
-from pipecat.pipeline.pipeline import Pipeline
-from pipecat.pipeline.runner import PipelineRunner
-from pipecat.pipeline.task import PipelineParams, PipelineTask
-from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
-from pipecat.processors.audio.audio_buffer_processor import AudioBufferProcessor
-from pipecat.serializers.exotel import ExotelFrameSerializer
-from pipecat.services.elevenlabs.tts import ElevenLabsTTSService
-from pipecat.services.deepgram.stt import DeepgramSTTService
-from pipecat.services.openai.llm import OpenAILLMService
-from pipecat.transports.network.fastapi_websocket import (
-    FastAPIWebsocketParams,
-    FastAPIWebsocketTransport,
-)
-
-# Load environment variables
-load_dotenv(override=True)
-
-# Configure logger
-logger.remove(0)
-logger.add(sys.stderr, level="DEBUG")
 
 # Create FastAPI app
-app = FastAPI(title="Pipecat Exotel Voice Chatbot", version="1.0.0")
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Allow all origins for testing
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-async def save_audio(server_name: str, audio: bytes, sample_rate: int, num_channels: int):
-    """Save audio recording to file"""
-    if len(audio) > 0:
-        filename = (
-            f"{server_name}_recording_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.wav"
-        )
-        with io.BytesIO() as buffer:
-            with wave.open(buffer, "wb") as wf:
-                wf.setsampwidth(2)
-                wf.setnchannels(num_channels)
-                wf.setframerate(sample_rate)
-                wf.writeframes(audio)
-            async with aiofiles.open(filename, "wb") as file:
-                await file.write(buffer.getvalue())
-        logger.info(f"Audio saved to {filename}")
-    else:
-        logger.info("No audio data to save")
-
-
-async def run_bot(websocket_client: WebSocket, call_id: str, testing: bool):
-    """Run the voice chatbot pipeline"""
-    transport = FastAPIWebsocketTransport(
-        websocket=websocket_client,
-        params=FastAPIWebsocketParams(
-            audio_in_enabled=True,
-            audio_out_enabled=True,
-            add_wav_header=False,
-            vad_enabled=True,
-            vad_analyzer=SileroVADAnalyzer(),
-            vad_audio_passthrough=True,
-            serializer=ExotelFrameSerializer(stream_sid=call_id),
-        ),
-    )
-
-    # Initialize services
-    llm = OpenAILLMService(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-4o")
-    stt = DeepgramSTTService(api_key=os.getenv("DEEPGRAM_API_KEY"), audio_passthrough=True)
-    tts = ElevenLabsTTSService(
-        api_key=os.getenv("ELEVEN_API_KEY"),
-        voice_id=os.getenv("ELEVEN_VOICE_ID"),
-    )
-
-    # System message
-    messages = [
-        {
-            "role": "system",
-            "content": "You are a helpful assistant named Tasha. Your output will be converted to audio so don't include special characters in your answers. Respond with a short sentence.",
-        },
-    ]
-
-    context = OpenAILLMContext(messages)
-    context_aggregator = llm.create_context_aggregator(context)
-    audiobuffer = AudioBufferProcessor(user_continuous_stream=not testing)
-
-    # Create pipeline
-    pipeline = Pipeline(
-        [
-            transport.input(),  # WebSocket input from client
-            stt,  # Speech-To-Text
-            context_aggregator.user(),
-            llm,  # LLM
-            tts,  # Text-To-Speech
-            transport.output(),  # WebSocket output to client
-            audiobuffer,  # Used to buffer the audio in the pipeline
-            context_aggregator.assistant(),
-        ]
-    )
-
-    task = PipelineTask(
-        pipeline,
-        params=PipelineParams(
-            audio_in_sample_rate=8000,
-            audio_out_sample_rate=8000,
-            allow_interruptions=True,
-        ),
-    )
-
-    @transport.event_handler("on_client_connected")
-    async def on_client_connected(transport, client):
-        # Start recording
-        await audiobuffer.start_recording()
-        # Kick off the conversation
-        messages.append({"role": "system", "content": "Please introduce yourself to the user."})
-        await task.queue_frames([context_aggregator.user().get_context_frame()])
-
-    @transport.event_handler("on_client_disconnected")
-    async def on_client_disconnected(transport, client):
-        await task.cancel()
-
-    @audiobuffer.event_handler("on_audio_data")
-    async def on_audio_data(buffer, audio, sample_rate, num_channels):
-        server_name = f"server_{websocket_client.client.port}"
-        await save_audio(server_name, audio, sample_rate, num_channels)
-
-    # Run the pipeline
-    runner = PipelineRunner(handle_sigint=False, force_gc=True)
-    await runner.run(task)
-
+app = FastAPI(title="Pipecat Voice Chatbot - Hugging Face", version="1.0.0")
+
+# Serve static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+templates = Jinja2Templates(directory="templates")
+
+@app.get("/", response_class=HTMLResponse)
+async def home(request: Request):
+    """Home page with WebSocket client"""
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Pipecat Voice Chatbot</title>
+        <style>
+            body { font-family: Arial, sans-serif; margin: 40px; }
+            .container { max-width: 800px; margin: 0 auto; }
+            .status { padding: 10px; margin: 10px 0; border-radius: 5px; }
+            .connected { background-color: #d4edda; color: #155724; }
+            .disconnected { background-color: #f8d7da; color: #721c24; }
+            .error { background-color: #f8d7da; color: #721c24; }
+            button { padding: 10px 20px; margin: 5px; font-size: 16px; }
+            #log { background: #f8f9fa; padding: 20px; border-radius: 5px; height: 300px; overflow-y: auto; }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>Pipecat Voice Chatbot</h1>
+            <div id="status" class="status disconnected">Disconnected</div>
+            <button onclick="connect()">Connect</button>
+            <button onclick="disconnect()">Disconnect</button>
+            <button onclick="sendStart()">Send Start Event</button>
+            <div id="log"></div>
+        </div>
+
+        <script>
+            let ws = null;
+            const status = document.getElementById('status');
+            const log = document.getElementById('log');
+
+            function logMessage(message) {
+                const div = document.createElement('div');
+                div.textContent = new Date().toLocaleTimeString() + ': ' + message;
+                log.appendChild(div);
+                log.scrollTop = log.scrollHeight;
+            }
+
+            function connect() {
+                const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+                const wsUrl = `${protocol}//${window.location.host}/media`;
+                
+                logMessage('Connecting to: ' + wsUrl);
+                
+                ws = new WebSocket(wsUrl);
+                
+                ws.onopen = function() {
+                    status.textContent = 'Connected';
+                    status.className = 'status connected';
+                    logMessage('Connected to WebSocket');
+                };
+                
+                ws.onmessage = function(event) {
+                    logMessage('Received: ' + event.data);
+                };
+                
+                ws.onclose = function() {
+                    status.textContent = 'Disconnected';
+                    status.className = 'status disconnected';
+                    logMessage('WebSocket connection closed');
+                };
+                
+                ws.onerror = function(error) {
+                    status.textContent = 'Error';
+                    status.className = 'status error';
+                    logMessage('WebSocket error: ' + error);
+                };
+            }
+
+            function disconnect() {
+                if (ws) {
+                    ws.close();
+                }
+            }
+
+            function sendStart() {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    const message = {
+                        event: 'start',
+                        streamSid: 'test_stream_' + Date.now(),
+                        mediaFormat: {
+                            sample_rate: 8000,
+                            channels: 1,
+                            encoding: 'linear16'
+                        }
+                    };
+                    ws.send(JSON.stringify(message));
+                    logMessage('Sent start event: ' + JSON.stringify(message));
+                } else {
+                    logMessage('WebSocket not connected');
+                }
+            }
+        </script>
+    </body>
+    </html>
+    """
 
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""
-    return {"status": "healthy", "message": "Pipecat Exotel Voice Chatbot is running"}
-
+    return {"status": "healthy", "message": "Pipecat Voice Chatbot is running on Hugging Face"}
 
 @app.websocket("/media")
-async def media_endpoint(websocket: WebSocket):
-    """WebSocket endpoint for Exotel media streaming"""
+async def media_endpoint(websocket):
+    """WebSocket endpoint - may not work on Hugging Face"""
     await websocket.accept()
-    print("[*] Exotel WebSocket connection accepted")
+    print("[*] WebSocket connection accepted")
     
     try:
         while True:
             data = await websocket.receive_text()
             message = json.loads(data)
-            print(f"\n[*] Received Exotel message: {json.dumps(message, indent=2)}")
+            print(f"[*] Received message: {json.dumps(message, indent=2)}")
             
-            # Handle start event to get call information
-            if message.get('event') == 'start':
-                stream_sid = message.get('streamSid', 'default')
-                print(f"Starting bot for stream SID: {stream_sid}")
-                await run_bot(websocket, stream_sid, app.state.testing)
-                break
+            # Echo back the message for testing
+            await websocket.send_text(json.dumps({
+                "status": "received",
+                "message": "WebSocket working!",
+                "original": message
+            }))
                 
     except Exception as e:
         print(f"[!] Error in media endpoint: {str(e)}")
 
-
-def main():
-    """Main function to run the server"""
-    parser = argparse.ArgumentParser(description="Pipecat Exotel Voice Chatbot Server")
-    parser.add_argument(
-        "-t", "--test", action="store_true", default=False, help="set the server in testing mode"
-    )
-    parser.add_argument(
-        "-p", "--port", type=int, default=8005, help="port to run the server on"
-    )
-    args, _ = parser.parse_known_args()
-
-    app.state.testing = args.test
-
-    print(f"[*] Pipecat Exotel Voice Chatbot running on port {args.port}")
-    print(f"[*] Health check: http://localhost:{args.port}/health")
-    print(f"[*] WebSocket endpoint: ws://localhost:{args.port}/media")
-    print(f"[*] Testing mode: {'enabled' if args.test else 'disabled'}")
-    print("")
-    print("Required environment variables:")
-    print("  OPENAI_API_KEY - Your OpenAI API key")
-    print("  DEEPGRAM_API_KEY - Your Deepgram API key")
-    print("  ELEVEN_API_KEY - Your ElevenLabs API key")
-    print("  ELEVEN_VOICE_ID - Your ElevenLabs voice ID")
-    print("")
-    
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=args.port
-    )
-
-
-if __name__ == "__main__":
-    main()