Create app.py

app.py

@@ -0,0 +1,421 @@
+# app.py
+import os
+import uuid
+import json
+import time
+import gradio as gr
+import numpy as np
+import torch
+import whisper
+import mysql.connector
+from mysql.connector import pooling
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from pydub import AudioSegment
+import tempfile
+import hashlib
+import datetime
+import secrets
+
+# Initialize models (lightweight versions for Spaces)
+ASR_MODEL = "base"  # Smaller Whisper model
+NLU_MODEL = "facebook/blenderbot-400M-distill"  # Smaller conversation model
+
+# Database configuration
+DB_CONFIG = {
+    "host": os.environ.get("DB_HOST", "localhost"),
+    "user": os.environ.get("DB_USER", "voicebot_user"),
+    "password": os.environ.get("DB_PASSWORD", "password"),
+    "database": os.environ.get("DB_NAME", "voicebot"),
+    "pool_name": "voicebot_pool",
+    "pool_size": 5
+}
+
+# Create connection pool
+try:
+    cnx_pool = mysql.connector.pooling.MySQLConnectionPool(**DB_CONFIG)
+    print("Database connection pool created successfully")
+except Exception as e:
+    print(f"Error creating database pool: {e}")
+    # Use in-memory dictionary as fallback
+    print("Using in-memory storage as fallback")
+    in_memory_db = {"clients": {}, "conversations": {}}
+
+# Initialize models
+print("Loading ASR model...")
+asr_model = whisper.load_model(ASR_MODEL)
+print("ASR model loaded")
+
+print("Loading NLU model...")
+tokenizer = AutoTokenizer.from_pretrained(NLU_MODEL)
+nlu_model = AutoModelForCausalLM.from_pretrained(NLU_MODEL)
+print("NLU model loaded")
+
+# Database schema initialization
+def initialize_database():
+    try:
+        conn = cnx_pool.get_connection()
+        cursor = conn.cursor()
+        
+        # Create tables if they don't exist
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS clients (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            name VARCHAR(255) NOT NULL,
+            email VARCHAR(255) NOT NULL UNIQUE,
+            phone VARCHAR(50),
+            api_key VARCHAR(64) NOT NULL UNIQUE,
+            pbx_type ENUM('Asterisk', 'FreeSwitch', '3CX', 'Nextiva', 'Other'),
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        """)
+        
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS conversations (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            client_id INT,
+            caller_id VARCHAR(50),
+            start_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            end_time TIMESTAMP NULL,
+            transcript TEXT,
+            FOREIGN KEY (client_id) REFERENCES clients(id)
+        )
+        """)
+        
+        conn.commit()
+        print("Database initialized successfully")
+        
+    except Exception as e:
+        print(f"Error initializing database: {e}")
+    finally:
+        if 'cursor' in locals():
+            cursor.close()
+        if 'conn' in locals():
+            conn.close()
+
+# Initialize database on startup
+initialize_database()
+
+# API Key Management
+def generate_api_key():
+    """Generate a secure API key"""
+    return hashlib.sha256(secrets.token_bytes(32)).hexdigest()
+
+def create_client(name, email, phone, pbx_type):
+    """Create a new client and generate API key"""
+    api_key = generate_api_key()
+    
+    try:
+        conn = cnx_pool.get_connection()
+        cursor = conn.cursor()
+        
+        query = """
+        INSERT INTO clients (name, email, phone, api_key, pbx_type)
+        VALUES (%s, %s, %s, %s, %s)
+        """
+        cursor.execute(query, (name, email, phone, api_key, pbx_type))
+        conn.commit()
+        
+        return {"success": True, "api_key": api_key}
+    except Exception as e:
+        print(f"Error creating client: {e}")
+        # Fallback to in-memory storage
+        if 'in_memory_db' in globals():
+            client_id = str(uuid.uuid4())
+            in_memory_db["clients"][client_id] = {
+                "name": name,
+                "email": email,
+                "phone": phone,
+                "api_key": api_key,
+                "pbx_type": pbx_type,
+                "created_at": datetime.datetime.now().isoformat()
+            }
+            return {"success": True, "api_key": api_key}
+        return {"success": False, "error": str(e)}
+    finally:
+        if 'cursor' in locals():
+            cursor.close()
+        if 'conn' in locals():
+            conn.close()
+
+def validate_api_key(api_key):
+    """Validate an API key and return client details"""
+    try:
+        conn = cnx_pool.get_connection()
+        cursor = conn.cursor(dictionary=True)
+        
+        query = "SELECT * FROM clients WHERE api_key = %s"
+        cursor.execute(query, (api_key,))
+        client = cursor.fetchone()
+        
+        return client
+    except Exception as e:
+        print(f"Error validating API key: {e}")
+        # Fallback to in-memory storage
+        if 'in_memory_db' in globals():
+            for client_id, client in in_memory_db["clients"].items():
+                if client["api_key"] == api_key:
+                    return client
+        return None
+    finally:
+        if 'cursor' in locals():
+            cursor.close()
+        if 'conn' in locals():
+            conn.close()
+
+# Voice Processing Functions
+def transcribe_audio(audio_array, sample_rate):
+    """Transcribe audio using Whisper"""
+    # Convert audio array to float32 if needed
+    if audio_array.dtype != np.float32:
+        audio_array = audio_array.astype(np.float32) / 32768.0  # Normalize 16-bit PCM
+    
+    # Get temporary file
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+        filename = temp_file.name
+    
+    # Convert and save audio
+    audio_segment = AudioSegment(
+        audio_array.tobytes(),
+        frame_rate=sample_rate,
+        sample_width=audio_array.dtype.itemsize,
+        channels=1
+    )
+    audio_segment.export(filename, format="wav")
+    
+    # Transcribe with Whisper
+    result = asr_model.transcribe(filename)
+    
+    # Clean up
+    os.unlink(filename)
+    
+    return result["text"]
+
+def generate_response(text):
+    """Generate a response using the NLU model"""
+    inputs = tokenizer(text, return_tensors="pt")
+    
+    # Generate a response
+    with torch.no_grad():
+        outputs = nlu_model.generate(
+            inputs["input_ids"],
+            max_length=100,
+            num_return_sequences=1,
+            temperature=0.7,
+            top_k=50,
+            top_p=0.95,
+            pad_token_id=tokenizer.eos_token_id
+        )
+    
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return response
+
+def log_conversation(client_id, caller_id, transcript):
+    """Log a conversation to the database"""
+    try:
+        conn = cnx_pool.get_connection()
+        cursor = conn.cursor()
+        
+        query = """
+        INSERT INTO conversations (client_id, caller_id, transcript)
+        VALUES (%s, %s, %s)
+        """
+        cursor.execute(query, (client_id, caller_id, json.dumps(transcript)))
+        conn.commit()
+        
+        return True
+    except Exception as e:
+        print(f"Error logging conversation: {e}")
+        # Fallback to in-memory storage
+        if 'in_memory_db' in globals():
+            conv_id = str(uuid.uuid4())
+            in_memory_db["conversations"][conv_id] = {
+                "client_id": client_id,
+                "caller_id": caller_id,
+                "start_time": datetime.datetime.now().isoformat(),
+                "transcript": transcript
+            }
+        return False
+    finally:
+        if 'cursor' in locals():
+            cursor.close()
+        if 'conn' in locals():
+            conn.close()
+
+# Voice Bot processing function
+def process_voice_interaction(audio, api_key, caller_id="unknown"):
+    """Process a voice interaction with the bot"""
+    # Validate API key
+    client = validate_api_key(api_key)
+    if not client:
+        return {"error": "Invalid API key"}
+    
+    # Process the audio
+    try:
+        transcription = transcribe_audio(audio[0], audio[1])
+        response_text = generate_response(transcription)
+        
+        # Log the conversation
+        transcript = {
+            "timestamp": time.time(),
+            "caller_id": caller_id,
+            "user_input": transcription,
+            "bot_response": response_text
+        }
+        
+        log_conversation(client["id"], caller_id, transcript)
+        
+        return {
+            "success": True,
+            "transcription": transcription,
+            "response": response_text
+        }
+    except Exception as e:
+        print(f"Error processing voice interaction: {e}")
+        return {"error": str(e)}
+
+# Admin functions
+def admin_create_client(name, email, phone, pbx_type):
+    """Admin interface to create a client"""
+    if not name or not email:
+        return {"error": "Name and email are required"}
+    
+    result = create_client(name, email, phone, pbx_type)
+    if result["success"]:
+        return {"success": True, "message": f"Client created with API key: {result['api_key']}"}
+    else:
+        return {"error": result.get("error", "Unknown error")}
+
+def admin_get_clients():
+    """Admin interface to get all clients"""
+    try:
+        conn = cnx_pool.get_connection()
+        cursor = conn.cursor(dictionary=True)
+        
+        query = "SELECT id, name, email, phone, pbx_type, created_at FROM clients"
+        cursor.execute(query)
+        clients = cursor.fetchall()
+        
+        return {"success": True, "clients": clients}
+    except Exception as e:
+        print(f"Error getting clients: {e}")
+        # Fallback to in-memory
+        if 'in_memory_db' in globals():
+            return {"success": True, "clients": list(in_memory_db["clients"].values())}
+        return {"error": str(e)}
+    finally:
+        if 'cursor' in locals():
+            cursor.close()
+        if 'conn' in locals():
+            conn.close()
+
+def admin_get_conversations():
+    """Admin interface to get all conversations"""
+    try:
+        conn = cnx_pool.get_connection()
+        cursor = conn.cursor(dictionary=True)
+        
+        query = """
+        SELECT c.id, cl.name as client_name, c.caller_id, c.start_time, c.end_time, c.transcript 
+        FROM conversations c
+        JOIN clients cl ON c.client_id = cl.id
+        ORDER BY c.start_time DESC
+        LIMIT 100
+        """
+        cursor.execute(query)
+        conversations = cursor.fetchall()
+        
+        # Parse transcript JSON
+        for conv in conversations:
+            if conv["transcript"]:
+                try:
+                    conv["transcript"] = json.loads(conv["transcript"])
+                except:
+                    pass
+        
+        return {"success": True, "conversations": conversations}
+    except Exception as e:
+        print(f"Error getting conversations: {e}")
+        # Fallback to in-memory
+        if 'in_memory_db' in globals():
+            return {"success": True, "conversations": list(in_memory_db["conversations"].values())}
+        return {"error": str(e)}
+    finally:
+        if 'cursor' in locals():
+            cursor.close()
+        if 'conn' in locals():
+            conn.close()
+
+# Gradio Interface
+def build_gradio_interface():
+    # Admin section
+    with gr.Blocks() as admin_interface:
+        gr.Markdown("# Voice Bot Admin Dashboard")
+        
+        with gr.Tab("Create Client"):
+            with gr.Row():
+                client_name = gr.Textbox(label="Client Name")
+                client_email = gr.Textbox(label="Email")
+            with gr.Row():
+                client_phone = gr.Textbox(label="Phone Number")
+                client_pbx = gr.Dropdown(label="PBX Type", choices=["Asterisk", "FreeSwitch", "3CX", "Nextiva", "Other"])
+            create_btn = gr.Button("Create Client")
+            create_output = gr.JSON(label="Result")
+            
+            create_btn.click(
+                admin_create_client,
+                inputs=[client_name, client_email, client_phone, client_pbx],
+                outputs=create_output
+            )
+        
+        with gr.Tab("View Clients"):
+            refresh_clients_btn = gr.Button("Refresh Client List")
+            clients_output = gr.JSON(label="Clients")
+            
+            refresh_clients_btn.click(
+                admin_get_clients,
+                inputs=[],
+                outputs=clients_output
+            )
+        
+        with gr.Tab("View Conversations"):
+            refresh_convs_btn = gr.Button("Refresh Conversations")
+            convs_output = gr.JSON(label="Recent Conversations")
+            
+            refresh_convs_btn.click(
+                admin_get_conversations,
+                inputs=[],
+                outputs=convs_output
+            )
+    
+    # Test interface for voice bot API
+    with gr.Blocks() as test_interface:
+        gr.Markdown("# Voice Bot Test Interface")
+        
+        with gr.Row():
+            api_key_input = gr.Textbox(label="API Key")
+            caller_id_input = gr.Textbox(label="Caller ID (optional)", value="test_caller")
+        
+        audio_input = gr.Audio(label="Speak", type="numpy", source="microphone")
+        test_btn = gr.Button("Process Audio")
+        
+        output_json = gr.JSON(label="Result")
+        
+        test_btn.click(
+            process_voice_interaction,
+            inputs=[audio_input, api_key_input, caller_id_input],
+            outputs=output_json
+        )
+    
+    # Create a tabbed interface
+    demo = gr.TabbedInterface(
+        [admin_interface, test_interface],
+        ["Admin Dashboard", "Test Interface"]
+    )
+    
+    return demo
+
+# Create and launch the interface
+interface = build_gradio_interface()
+
+# Launch for Hugging Face Spaces
+interface.launch()