Update app.py

app.py

@@ -1,331 +1,233 @@
-from simple_salesforce import Salesforce
-import logging
-from flask import Flask, render_template_string, request, jsonify, redirect, url_for
-import speech_recognition as sr
-from tempfile import NamedTemporaryFile
+import torch
+from flask import Flask, render_template, request, jsonify, redirect
+import json
 import os
-import ffmpeg
-from werkzeug.exceptions import BadRequest
+from transformers import pipeline
 from gtts import gTTS
+from pydub import AudioSegment
+from pydub.silence import detect_nonsilent
+from transformers import AutoConfig  # Import AutoConfig for the config object
 import time
+from waitress import serve
+from simple_salesforce import Salesforce
+import requests  # Import requests for exception handling
 
 app = Flask(__name__)
-logging.basicConfig(level=logging.DEBUG)
 
-# Salesforce connection setup with error handling
-def connect_to_salesforce():
-    try:
-        sf = Salesforce(
-            username='diggavalli98@gmail.com', 
-            password='Sati@1020', 
-            security_token='sSSjyhInIsUohKpG8sHzty2q', 
-            consumer_key='3MVG9WVXk15qiz1JbtW1tT9a7Wnkos2RuGamw6p1lC5uPescT5NB2nPygpo6rQ87K1T.zBEn.wR.A6JdgHnIU', 
-            consumer_secret='A75C6B7801D5D20BED0E46631CF58C4F7FF28E4DAF442FE667553D29C35C0451'
-        )
-        logging.info("Successfully connected to Salesforce")
-        return sf
-    except Exception as e:
-        logging.error(f"Error connecting to Salesforce: {str(e)}")
-        return None
+# Use whisper-small for faster processing and better speed
+device = "cuda" if torch.cuda.is_available() else "cpu"
 
-sf = connect_to_salesforce()
+# Create config object to set timeout and other parameters
+config = AutoConfig.from_pretrained("openai/whisper-small")
+config.update({"timeout": 60})  # Set timeout to 60 seconds
 
-# Global variables
-cart = []  # To store items, quantities, and prices
-MENU = {}
+# Salesforce connection details
+try:
+    print("Attempting to connect to Salesforce...")
+    sf = Salesforce(username='diggavalli98@gmail.com', password='Sati@1020', security_token='sSSjyhInIsUohKpG8sHzty2q')
+    print("Connected to Salesforce successfully!")
+    print("User Info:", sf.UserInfo)  # Log the user info to verify the connection
+except Exception as e:
+    print(f"Failed to connect to Salesforce: {str(e)}")
 
-current_category = None
-current_item = None
-awaiting_quantity = False
+# Functions for Salesforce operations
+def create_salesforce_record(sf, name, email, phone_number):
+    try:
+        customer_login = sf.Customer_Login__c.create({
+            'Name': name,
+            'Email__c': email,
+            'Phone_Number__c': phone_number
+        })
+        return customer_login
+    except Exception as e:
+        raise Exception(f"Failed to create record: {str(e)}")
+
+def get_menu_items(sf):
+    query = "SELECT Name, Price__c, Ingredients__c, Category__c FROM Menu_Item__c"
+    result = sf.query(query)
+    return result['records']
 
-# Fetching menu items dynamically from Salesforce
-def get_menu_items():
-    menu_items = {}
+# Voice-related functions
+def generate_audio_prompt(text, filename):
     try:
-        query = "SELECT Name, Category__c, Price__c, Ingredients__c FROM Menu_Item__c"
-        results = sf.query_all(query)
-
-        # Organizing the menu items by category
-        for record in results['records']:
-            category = record['Category__c']
-            item_name = record['Name']
-            price = record['Price__c']
-
-            if category not in menu_items:
-                menu_items[category] = {}
-            menu_items[category][item_name] = price
-        
-        return menu_items
+        tts = gTTS(text)
+        tts.save(os.path.join("static", filename))
+    except gtts.tts.gTTSError as e:
+        print(f"Error: {e}")
+        print("Retrying after 5 seconds...")
+        time.sleep(5)  # Wait for 5 seconds before retrying
+        generate_audio_prompt(text, filename)
+
+# Utility functions
+def convert_to_wav(input_path, output_path):
+    try:
+        audio = AudioSegment.from_file(input_path)
+        audio = audio.set_frame_rate(16000).set_channels(1)  # Convert to 16kHz, mono
+        audio.export(output_path, format="wav")
     except Exception as e:
-        logging.error(f"Error fetching menu items from Salesforce: {str(e)}")
-        return {}
-
-MENU = get_menu_items()
-
-# HTML Template for Frontend (for register, login, and menu pages)
-html_code = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Register / Login</title>
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            text-align: center;
-            background-color: #f4f4f9;
-        }
-        h1 {
-            color: #333;
-        }
-        .status, .response {
-            margin-top: 20px;
-        }
-    </style>
-</head>
-<body>
-    <h1>Welcome to Biryani Hub</h1>
-    <div id="welcomePage">
-        <button onclick="startRegistration()">New Customer</button>
-        <button onclick="startLogin()">Existing Customer</button>
-    </div>
-
-    <div id="registrationPage" style="display: none;">
-        <h2>Register</h2>
-        <form action="/register" method="POST">
-            <label for="name">Name</label><br>
-            <input type="text" id="name" name="name" required><br>
-            <label for="email">Email</label><br>
-            <input type="email" id="email" name="email" required><br>
-            <label for="phone">Phone</label><br>
-            <input type="text" id="phone" name="phone" required><br>
-            <button type="submit">Register</button>
-        </form>
-    </div>
-
-    <div id="loginPage" style="display: none;">
-        <h2>Login</h2>
-        <form action="/login" method="POST">
-            <label for="email">Email</label><br>
-            <input type="email" id="email" name="email" required><br>
-            <label for="phone">Phone</label><br>
-            <input type="text" id="phone" name="phone" required><br>
-            <button type="submit">Login</button>
-        </form>
-    </div>
-
-    <div id="menuPage" style="display: none;">
-        <h1>AI Dining Assistant</h1>
-        <div class="status" id="status">Starting interaction...</div>
-        <div class="response" id="response" style="display: none;">Response will appear here...</div>
-        <button onclick="showMenu()">Show Menu</button>
-    </div>
-
-    <script>
-        function startRegistration() {
-            document.getElementById('welcomePage').style.display = 'none';
-            document.getElementById('registrationPage').style.display = 'block';
-        }
-
-        function startLogin() {
-            document.getElementById('welcomePage').style.display = 'none';
-            document.getElementById('loginPage').style.display = 'block';
-        }
-
-        function showMenu() {
-            document.getElementById('menuPage').style.display = 'block';
-            const categories = {{ MENU | tojson }};
-            let menuText = "We have the following categories: ";
-            for (let category in categories) {
-                menuText += category + " ";
-            }
-            document.getElementById('status').innerText = menuText;
-        }
-    </script>
-</body>
-</html>
-"""
+        print(f"Error: {str(e)}")
+        raise Exception(f"Audio conversion failed: {str(e)}")
+
+def is_silent_audio(audio_path):
+    audio = AudioSegment.from_wav(audio_path)
+    nonsilent_parts = detect_nonsilent(audio, min_silence_len=500, silence_thresh=audio.dBFS-16)  # Reduced silence duration
+    print(f"Detected nonsilent parts: {nonsilent_parts}")
+    return len(nonsilent_parts) == 0  # If no speech detected
 
+# Routes and Views
 @app.route("/")
 def index():
-    return render_template_string(html_code)
-
-# Register Page
-@app.route("/register", methods=["GET", "POST"])
-def register():
-    if request.method == "POST":
-        name = request.form.get('name')
-        email = request.form.get('email')
-        phone = request.form.get('phone')
-        if not name or not email or not phone:
-            logging.error("Missing required fields: Name, Email, Phone.")
-            return jsonify({"error": "All fields are required."}), 400
-
-        if not sf:
-            logging.error("Salesforce connection failed.")
-            return jsonify({"error": "Salesforce connection failed."}), 500
-
-        # Create a record in Salesforce
-        try:
-            customer_login = sf.Customer_Login__c.create({
-                'Name': name,
-                'Email__c': email,
-                'Phone_Number__c': phone
-            })
-            logging.info(f"Customer registered successfully with ID: {customer_login['id']}")
-            return redirect(url_for('menu'))  # Redirect to menu after successful registration
-        except Exception as e:
-            logging.error(f"Error during registration: {str(e)}")
-            return jsonify({'error': f'Failed to create record in Salesforce: {str(e)}'}), 500
-
-    return render_template_string(html_code)
-
-# Login Page
-@app.route("/login", methods=["GET", "POST"])
+    return render_template("index.html")
+
+@app.route("/dashboard", methods=["GET"])
+def dashboard():
+    return render_template("dashboard.html")  # Render the dashboard template
+
+@app.route('/login', methods=['POST'])
 def login():
-    if request.method == "POST":
-        email = request.form.get('email')
-        phone = request.form.get('phone')
-
-        if not email or not phone:
-            logging.error("Missing required fields: Email, Phone.")
-            return jsonify({"error": "Email and phone are required."}), 400
-
-        if not sf:
-            logging.error("Salesforce connection failed.")
-            return jsonify({"error": "Salesforce connection failed."}), 500
-
-        # Check if the customer exists in Salesforce
-        try:
-            customer_query = sf.query(f"SELECT Id, Name FROM Customer_Login__c WHERE Email__c = '{email}' AND Phone_Number__c = '{phone}'")
-            if customer_query['totalSize'] == 0:
-                logging.error("Customer not found.")
-                return jsonify({"error": "Customer not found."}), 404
-            logging.info("Customer logged in successfully")
-            return redirect(url_for('menu'))  # Redirect to menu after successful login
-        except Exception as e:
-            logging.error(f"Error during login: {str(e)}")
-            return jsonify({'error': f'Failed to query Salesforce: {str(e)}'}), 500
-
-    return render_template_string(html_code)
-
-# Menu Page
-@app.route("/menu")
-def menu():
-    return render_template_string(html_code)
-
-@app.route("/process-audio", methods=["POST"])
-def process_audio():
-    global current_category, current_item, awaiting_quantity
+    # Get data from voice bot (name, email, phone number)
+    data = request.json  # Assuming voice bot sends JSON data
+    name = data.get('name')
+    email = data.get('email')
+    phone_number = data.get('phone_number')
+
+    if not name or not email or not phone_number:
+        return jsonify({'error': 'Missing required fields'}), 400
+
     try:
-        audio_file = request.files.get("audio")
-        if not audio_file:
-            raise BadRequest("No audio file provided.")
+        customer_login = create_salesforce_record(sf, name, email, phone_number)
+        return redirect("/menu")  # Redirect to the menu page after successful login
+    except Exception as e:
+        return jsonify({'error': f'Failed to create record in Salesforce: {str(e)}'}), 500
 
-        temp_file = NamedTemporaryFile(delete=False, suffix=".webm")
-        audio_file.save(temp_file.name)
+@app.route("/submit", methods=["POST"])
+def submit():
+    data = request.json
+    name = data.get('name')
+    email = data.get('email')
+    phone = data.get('phone')
 
-        if os.path.getsize(temp_file.name) == 0:
-            raise BadRequest("Uploaded audio file is empty.")
+    if not name or not email or not phone:
+        return jsonify({'error': 'Missing data'}), 400
 
-        converted_file = NamedTemporaryFile(delete=False, suffix=".wav")
-        ffmpeg.input(temp_file.name).output(
-            converted_file.name, acodec="pcm_s16le", ac=1, ar="16000"
-        ).run(overwrite_output=True)
+    try:
+        # Create Salesforce record
+        customer_login = sf.Customer_Login__c.create({
+            'Name': name,
+            'Email__c': email,
+            'Phone_Number__c': phone
+        })
+
+        if customer_login.get('id'):
+            print(f"Success: Customer record created with ID: {customer_login['id']}")
+            return jsonify({'success': True})
+        else:
+            print("Failed: No ID returned after creating the record.")
+            return jsonify({'error': 'Failed to create record'}), 500
 
-        recognizer = sr.Recognizer()
-        with sr.AudioFile(converted_file.name) as source:
-            audio_data = recognizer.record(source)
-            try:
-                command = recognizer.recognize_google(audio_data)
-                logging.info(f"Recognized command: {command}")
-                response = process_command(command)
-            except sr.UnknownValueError:
-                response = "Sorry, I couldn't understand your command. Could you please repeat?"
-            except sr.RequestError as e:
-                response = f"Error with the speech recognition service: {e}"
-
-        return jsonify({"response": response})
-
-    except BadRequest as br:
-        return jsonify({"response": f"Bad Request: {str(br)}"}), 400
     except Exception as e:
-        logging.error(f"Error processing audio: {str(e)}")
-        return jsonify({"response": f"An error occurred: {str(e)}"}), 500
-    finally:
-        os.unlink(temp_file.name)
-        os.unlink(converted_file.name)
-
-def process_command(command):
-    global cart, MENU, current_category, current_item, awaiting_quantity
-    command = command.lower()
-
-    # Handle quantity input
-    if awaiting_quantity:
-        quantity = extract_quantity(command)
-        if quantity:
-            cart.append((current_item, MENU[current_category][current_item], quantity))
-            awaiting_quantity = False
-            item = current_item
-            current_item = None
-            total = sum(i[1] * i[2] for i in cart)
-            cart_summary = ", ".join([f"{i[0]} x{i[2]} (₹{i[1] * i[2]})" for i in cart])
-            return f"Added {quantity} x {item} to your cart. Your current cart: {cart_summary}. Total: ₹{total}. Would you like to add more items?"
-        else:
-            return "Sorry, I couldn't understand the quantity. Please provide a valid quantity."
-
-    # Handle category selection
-    for category, items in MENU.items():
-        if category.lower() in command:
-            current_category = category
-            item_list = ", ".join([f"{item} (₹{price})" for item, price in items.items()])
-            return f"{category} menu: {item_list}. What would you like to order?"
-
-    # Handle item selection with dynamic matching
-    if current_category:
-        for item in MENU[current_category].keys():
-            if item.lower().startswith(command) or command in item.lower():
-                current_item = item
-                awaiting_quantity = True
-                return f"How many quantities of {current_item} would you like?"
-
-    # Handle item removal
-    if "remove" in command:
-        for item in cart:
-            if item[0].lower() in command:
-                cart.remove(item)
-                total = sum(i[1] * i[2] for i in cart)
-                cart_summary = ", ".join([f"{i[0]} x{i[2]} (₹{i[1] * i[2]})" for i in cart])
-                return f"Removed {item[0]} from your cart. Updated cart: {cart_summary}. Total: ₹{total}."
-        return "The item you are trying to remove is not in your cart."
-
-    # Handle final order
-    if "final order" in command or "submit" in command or "Proceed" in command or "place the order" in command:
-        if cart:
-            order_details = ", ".join([f"{item[0]} x{item[2]} (₹{item[1] * item[2]})" for item in cart])
-            total = sum(item[1] * item[2] for item in cart)
-            cart.clear()
-            return f"Your final order is: {order_details}. Total price: ₹{total}. Your order will arrive soon, Thank you for visiting Biryani Hub!"
-        else:
-            return "Your cart is empty. Please add items before placing the final order."
-
-    # Handle cart details
-    if "cart details" in command:
-        if cart:
-            cart_summary = "\n".join([f"{i[0]} x{i[2]} (₹{i[1] * i[2]})" for i in cart])
-            total = sum(i[1] * i[2] for i in cart)
-            return f"Your cart contains:\n{cart_summary}\nTotal: ₹{total}."
+        print(f"Error: {str(e)}")  # Print error message if an exception occurs
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route("/menu", methods=["GET"])
+def menu_page():
+    menu_items = get_menu_items(sf)  # Fetch menu items from Salesforce
+    menu_data = [{"name": item['Name'], "price": item['Price__c'], "ingredients": item['Ingredients__c'], "category": item['Category__c']} for item in menu_items]
+    return render_template("menu_page.html", menu_items=menu_data)
+
+# Route for handling order
+@app.route("/order", methods=["POST"])
+def place_order():
+    item_name = request.json.get('item_name')
+    quantity = request.json.get('quantity')
+    order_data = {"Item__c": item_name, "Quantity__c": quantity}
+    sf.Order__c.create(order_data)
+    return jsonify({"success": True, "message": f"Order for {item_name} placed successfully."})
+
+# Route to handle the cart
+@app.route("/cart", methods=["GET"])
+def cart():
+    cart_items = []  # Placeholder for cart items
+    return render_template("cart_page.html", cart_items=cart_items)
+
+# Route for the order summary page
+@app.route("/order-summary", methods=["GET"])
+def order_summary():
+    order_details = []  # Placeholder for order details
+    return render_template("order_summary.html", order_details=order_details)
+
+@app.route("/transcribe", methods=["POST"])
+def transcribe():
+    if "audio" not in request.files:
+        print("No audio file provided")
+        return jsonify({"error": "No audio file provided"}), 400
+
+    audio_file = request.files["audio"]
+    input_audio_path = os.path.join("static", "temp_input.wav")
+    output_audio_path = os.path.join("static", "temp.wav")
+    audio_file.save(input_audio_path)
+
+    try:
+        # Convert to WAV
+        convert_to_wav(input_audio_path, output_audio_path)
+
+        # Check for silence
+        if is_silent_audio(output_audio_path):
+            return jsonify({"error": "No speech detected. Please try again."}), 400
         else:
-            return "Your cart is empty."
+            print("Audio contains speech, proceeding with transcription.")
+
+        # Use Whisper ASR model for transcription
+        result = None
+        retry_attempts = 3
+        for attempt in range(retry_attempts):
+            try:
+                result = pipeline("automatic-speech-recognition", model="openai/whisper-small", device=0 if torch.cuda.is_available() else -1, config=config)
+                print(f"Transcribed text: {result['text']}")
+                break
+            except requests.exceptions.ReadTimeout:
+                print(f"Timeout occurred, retrying attempt {attempt + 1}/{retry_attempts}...")
+                time.sleep(5)
+
+        if result is None:
+            return jsonify({"error": "Unable to transcribe audio after retries."}), 500
 
-    # Handle menu request
-    if "menu" in command or "yes" in command or "yeah" in command:
-        categories = ", ".join(MENU.keys())
-        return f"We have the following categories: {categories}. Please select a category to proceed."
+        transcribed_text = result["text"].strip().capitalize()
+        print(f"Transcribed text: {transcribed_text}")
 
-    # Default response
-    return "Sorry, I didn't understand that. Please try again."
+        # Extract name, email, and phone number from the transcribed text
+        parts = transcribed_text.split()
+        name = parts[0] if len(parts) > 0 else "Unknown Name"
+        email = parts[1] if '@' in parts[1] else "unknown@domain.com"
+        phone_number = parts[2] if len(parts) > 2 else "0000000000"
+        print(f"Parsed data - Name: {name}, Email: {email}, Phone Number: {phone_number}")
+
+        # Confirm details before submission
+        confirmation = f"Is this correct? Name: {name}, Email: {email}, Phone: {phone_number}"
+        generate_audio_prompt(confirmation, "confirmation.mp3")
+
+        # Simulate confirmation via user action
+        user_confirms = True  # Assuming the user confirms, you can replace this with actual user input logic
+
+        if user_confirms:
+            # Create record in Salesforce
+            salesforce_response = create_salesforce_record(name, email, phone_number)
+
+            # Log the Salesforce response
+            print(f"Salesforce record creation response: {salesforce_response}")
+
+            # Check if the response contains an error
+            if "error" in salesforce_response:
+                print(f"Error creating record in Salesforce: {salesforce_response['error']}")
+                return jsonify(salesforce_response), 500
+
+            return jsonify({"text": transcribed_text, "salesforce_record": salesforce_response})
+
+    except Exception as e:
+        print(f"Error in transcribing or processing: {str(e)}")
+        return jsonify({"error": f"Speech recognition error: {str(e)}"}), 500
 
+# Start Production Server
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+    serve(app, host="0.0.0.0", port=7860)