AIVoice6

Runtime error

App Files Files Community

dschandra commited on Feb 20

Commit

e71240e

verified ·

1 Parent(s): 3287093

Update app.py

Browse files

Files changed (1) hide show

app.py +333 -54

app.py CHANGED Viewed

@@ -1,67 +1,346 @@
-# Import required libraries
-from faster_whisper import WhisperModel
-from transformers import pipeline
-from bark import generate_audio
-from flask import Flask, request, jsonify
-# Initialize Flask app
 app = Flask(__name__)
-# Load models
-speech_model = WhisperModel("tiny", device="cuda", compute_type="float16")
-nlp_model = pipeline("text-generation", model="gpt-3.5-turbo")
-@app.route('/process_audio', methods=['POST'])
 def process_audio():
     try:
-        # Step 1: Receive the audio file from the user
-        audio_file = request.files['audio']
-        audio_path = f"./temp/{audio_file.filename}"
-        audio_file.save(audio_path)
-        # Step 2: Transcribe the audio to text
-        transcription = transcribe_audio(audio_path)
-        # Step 3: Generate a response based on the transcription
-        response_text = generate_response(transcription)
-        # Step 4: Synthesize speech from the response text
-        response_audio = synthesize_speech(response_text)
-        # Save the response audio to a file
-        response_audio_path = f"./temp/response_audio.wav"
-        response_audio.export(response_audio_path, format="wav")
-        return jsonify({
-            "transcription": transcription,
-            "response_text": response_text,
-            "response_audio_path": response_audio_path
-        })
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-def transcribe_audio(audio_path):
-    """
-    Transcribe audio using Whisper.
-    """
-    segments, info = speech_model.transcribe(audio_path)
-    transcription = " ".join([segment.text for segment in segments])
-    return transcription
-def generate_response(user_input):
-    """
-    Generate text response using GPT-3.5-turbo.
-    """
-    response = nlp_model(user_input, max_length=100, do_sample=True)
-    return response[0]['generated_text']
-def synthesize_speech(text):
-    """
-    Generate speech audio using Bark.
-    """
-    audio_array = generate_audio(text)
-    return audio_array
-# Run the app
 if __name__ == "__main__":
-    app.run(debug=True, host="0.0.0.0", port=5000)

+from flask import Flask, render_template_string, request, jsonify
+from simple_salesforce import Salesforce
+import logging
+from tempfile import NamedTemporaryFile
+import os
+import re
+import traceback
+import ffmpeg
+import speech_recognition as sr
+from werkzeug.exceptions import BadRequest
+from datetime import datetime
+from word2number import w2n  # Import word-to-number conversion library
 app = Flask(__name__)
+logging.basicConfig(level=logging.INFO)
+# Salesforce connection setup
+sf = Salesforce(
+    username='[email protected]',
+    password='Sati@1020',
+    security_token='sSSjyhInIsUohKpG8sHzty2q',
+    consumer_key='3MVG9WVXk15qiz1JbtW1tT9a7Wnkos2RuGamw6p1lC5uPescT5NB2nPygpo6rQ87K1T.zBEn.wR.A6JdgHnIU',
+    consumer_secret='A75C6B7801D5D20BED0E46631CF58C4F7FF28E4DAF442FE667553D29C35C0451'
+)
+# Global variables
+cart = []  # To store items, quantities, prices, and add-ons
+current_category = None
+awaiting_preference = True
+awaiting_quantity = False
+user_email = None  # Will be set later once the user provides it
+awaiting_item_selection = False  # Flag to know when to ask for item selection
+user_name = None  # Will be set once the user provides their name
+# Function to fetch menu items from Salesforce based on the category filter
+def get_menu_items(category):
+    category_filter = ''
+    # Determine the category filter (Veg, Non-Veg, or All)
+    if category == 'Veg':
+        category_filter = 'Veg'
+    elif category == 'Non-Veg':
+        category_filter = 'Non veg'
+    elif category == 'All':
+        category_filter = ''  # No filter for 'All'
+    # Query Salesforce based on the category filter
+    if category_filter == '':
+        query = "SELECT Id, Name, Price__c, Image1__c, Veg_NonVeg__c, Section__c FROM Menu_Item__c"
+    else:
+        query = f"""
+            SELECT Id, Name, Price__c, Image1__c, Veg_NonVeg__c, Section__c
+            FROM Menu_Item__c
+            WHERE Veg_NonVeg__c = '{category_filter}' OR Veg_NonVeg__c = 'both'
+        """
+    # Execute the query
+    result = sf.query_all(query)
+    return result['records']
+# Function to save cart and order details into Salesforce
+def save_order_to_salesforce(cart, user_email, total_amount):
+    # Prepare the order object
+    order_items = ", ".join([f"{item['Name']} x {item['Quantity']}" for item in cart])
+    order = {
+        'Customer_Email__c': user_email,
+        'Order_Date_Time__c': datetime.now(),
+        'Order_Items__c': order_items,
+        'Total_Amount__c': total_amount,
+        'Status__c': 'Pending'  # Assuming the status is 'Pending' initially
+    }
+    # Insert order record into Salesforce
+    order_record = sf.Order__c.create(order)
+    return order_record
+# HTML Template for Frontend
+html_code = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Dining Assistant</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            text-align: center;
+            background-color: #f4f4f9;
+        }
+        h1 {
+            color: #333;
+        }
+        .mic-button {
+            width: 80px;
+            height: 80px;
+            border-radius: 50%;
+            background-color: #007bff;
+            color: white;
+            font-size: 24px;
+            border: none;
+            cursor: pointer;
+        }
+        .status, .response {
+            margin-top: 20px;
+        }
+    </style>
+</head>
+<body>
+    <h1>AI Dining Assistant</h1>
+    <button class="mic-button" id="mic-button">🎤</button>
+    <div class="status" id="status">Press the mic button to start...</div>
+    <div class="response" id="response" style="display: none;">Response will appear here...</div>
+    <script>
+        const micButton = document.getElementById('mic-button');
+        const status = document.getElementById('status');
+        const response = document.getElementById('response');
+        let isListening = false;
+        micButton.addEventListener('click', () => {
+            if (!isListening) {
+                isListening = true;
+                greetUser();
+            }
+        });
+        // Greeting the user and asking for their name
+        function greetUser() {
+            const utterance = new SpeechSynthesisUtterance("Hi, welcome to Biryani Hub! Can I know your name so I can greet you personally?");
+            speechSynthesis.speak(utterance);
+            utterance.onend = () => {
+                status.textContent = "Listening for your name...";
+                startListening();
+            };
+        }
+        // Start listening for the user's response
+        async function startListening() {
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            const mediaRecorder = new MediaRecorder(stream, { mimeType: "audio/webm;codecs=opus" });
+            const audioChunks = [];
+            mediaRecorder.ondataavailable = (event) => audioChunks.push(event.data);
+            mediaRecorder.onstop = async () => {
+                const audioBlob = new Blob(audioChunks, { type: "audio/webm" });
+                const formData = new FormData();
+                formData.append("audio", audioBlob);
+                status.textContent = "Processing your preference... Please wait.";
+                try {
+                    const result = await fetch("/process-audio", { method: "POST", body: formData });
+                    const data = await result.json();
+                    response.textContent = data.response;
+                    response.style.display = "block";
+                    const utterance = new SpeechSynthesisUtterance(data.response);
+                    speechSynthesis.speak(utterance);
+                    utterance.onend = () => {
+                        if (!data.response.includes("Goodbye") && !data.response.includes("final order")) {
+                            startListening(); // Continue listening
+                        } else {
+                            status.textContent = "Conversation ended.";
+                            isListening = false;
+                        }
+                    };
+                } catch (error) {
+                    response.textContent = "Sorry, I couldn’t understand that. Could you please repeat?";
+                    status.textContent = "Press the mic button to restart.";
+                    isListening = false;
+                }
+            };
+            mediaRecorder.start();
+            setTimeout(() => mediaRecorder.stop(), 5000); // Stop recording after 5 seconds
+        }
+    </script>
+</body>
+</html>
+"""
+@app.route("/")
+def index():
+    return render_template_string(html_code)
+@app.route("/process-audio", methods=["POST"])
 def process_audio():
+    global awaiting_preference, current_category, awaiting_quantity, cart, awaiting_item_selection, user_name
     try:
+        audio_file = request.files.get("audio")
+        if not audio_file:
+            raise BadRequest("No audio file provided.")
+        temp_file = NamedTemporaryFile(delete=False, suffix=".webm")
+        audio_file.save(temp_file.name)
+        if os.path.getsize(temp_file.name) == 0:
+            raise BadRequest("Uploaded audio file is empty.")
+        converted_file = NamedTemporaryFile(delete=False, suffix=".wav")
+        ffmpeg.input(temp_file.name).output(
+            converted_file.name, acodec="pcm_s16le", ac=1, ar="16000", loglevel='error'
+        ).run(overwrite_output=True)
+        recognizer = sr.Recognizer()
+        with sr.AudioFile(converted_file.name) as source:
+            recognizer.adjust_for_ambient_noise(source, duration=1)  # Adjust for ambient noise
+            audio_data = recognizer.record(source, duration=10)  # Increase the duration
+            try:
+                command = recognizer.recognize_google(audio_data)
+                logging.info(f"Recognized command: {command}")  # Log the recognized 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:
+        return jsonify({"response": f"An error occurred: {str(e)}"}), 500
+    finally:
+        os.unlink(temp_file.name)
+        os.unlink(converted_file.name)
+# Updated Email Handling
+def process_command(command):
+    global awaiting_preference, current_category, awaiting_quantity, cart, awaiting_item_selection, user_email, user_name
+    logging.info(f"Processing command: {command}")
+    try:
+        # Step 1: Handle user name input (personalize the greeting)
+        if user_name is None and "my name is" in command:
+            user_name = command.replace("my name is", "").strip()
+            return jsonify({"response": f"Hello {user_name}! Nice to meet you. Please choose your preference: Veg, Non-Veg, or All."})
+        # Step 2: Handle preference (Veg/Non-Veg/All)
+        if awaiting_preference:
+            if "veg" in command:
+                current_category = 'Veg'
+            elif "non-veg" in command:
+                current_category = 'Non-Veg'
+            elif "all" in command:
+                current_category = 'All'
+            else:
+                return jsonify({"response": "I didn't catch your preference. Please choose Veg, Non-Veg, or All."})
+            awaiting_preference = False
+            awaiting_item_selection = True  # Now ready for item selection
+            return jsonify({"response": f"Great! You've selected {current_category}. What would you like to order?"})
+        # Step 3: Handle item selection
+        if awaiting_item_selection:
+            menu_items = get_menu_items(current_category)  # Simulate fetching menu items
+            selected_item = next((item for item in menu_items if item['Name'].lower() in command), None)
+            if selected_item:
+                cart.append({"Name": selected_item['Name'], "Price__c": selected_item['Price__c'], "Quantity": 0})
+                awaiting_item_selection = False
+                awaiting_quantity = True
+                return jsonify({"response": f"You selected {selected_item['Name']}. How many would you like to order?"})
+            return jsonify({"response": "I didn't catch that. Please say the name of the item you want to order."})
+        # Step 4: Handle quantity selection
+        if awaiting_quantity:
+            try:
+                quantity = int(command)
+                if quantity > 0:
+                    cart[-1]["Quantity"] = quantity
+                    awaiting_quantity = False
+                    return jsonify({"response": f"Quantity set to {quantity}. Please provide your email to complete the order."})
+                else:
+                    return jsonify({"response": "Quantity must be greater than zero."})
+            except ValueError:
+                return jsonify({"response": "Please provide a valid number for quantity."})
+        # Step 5: Handle email input
+        if "my email is" in command:
+            email_part = command.replace("my email is", "").strip()
+            email_command = email_part.replace(' at ', '@').replace(' dot ', '.').replace(' ', '')
+            logging.info(f"Processed email command: {email_command}")
+            email_pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
+            match = re.match(email_pattern, email_command)
+            if match:
+                user_email = match.group(0)
+                return jsonify({"response": f"Got it! Your email is {user_email}. Now, your order will be processed. Would you like to confirm your order?"})
+            else:
+                return jsonify({"response": "Sorry, that doesn't look like a valid email. Can you please provide it again?"})
+        # Step 6: Handle order finalization commands
+        if "final order" in command or "confirm my order" in command or "place the order" in command or "confirm order" in command:
+            return place_order()
+        return jsonify({"response": "I'm not sure what you're trying to do. Can you please repeat?"})
+    except Exception as e:
+        logging.error(f"An error occurred while processing the command: {str(e)}")
+        logging.error(f"Stack Trace: {traceback.format_exc()}")  # Log full error details
+        return jsonify({"response": "Sorry, there was an error processing your request."}), 500
+# Function to place the order
+def place_order():
+    global cart, user_email, user_name
+    try:
+        # Calculate the total amount for the order
+        total_amount = sum([item['Price__c'] * item['Quantity'] for item in cart])
+        # Step 1: Save the main order record to Salesforce
+        order_record = save_order_to_salesforce(cart, user_email, total_amount)
+        # Step 2: Query Salesforce for the order just placed using the user's email and name
+        order_query = f"""
+            SELECT Id, Name, Customer_Email__c
+            FROM Order__c
+            WHERE Customer_Email__c = '{user_email}' AND Name = '{user_name}'
+            ORDER BY CreatedDate DESC LIMIT 1
+        """
+        order_result = sf.query_all(order_query)
+        # Ensure the order was created successfully
+        if not order_result['records']:
+            return jsonify({"response": "Failed to retrieve the placed order. Please try again."})
+        order_id = order_result['records'][0]['Id']
+        # Step 3: Add the food items as related records to the Order__c
+        for item in cart:
+            order_item = {
+                'Order__c': order_id,  # Link the item to the specific order
+                'Item_Name__c': item['Name'],  # Item name
+                'Quantity__c': item['Quantity'],  # Item quantity
+                'Price__c': item['Price__c'],  # Item price
+            }
+            sf.Order_Item__c.create(order_item)  # Assuming you have a custom Order_Item__c object for items
+        # Step 4: Clear the cart after placing the order
+        cart = []  # Clear the cart
+        # Return the success message
+        return jsonify({"response": f"Order placed successfully! Total amount: ₹{total_amount}"})
+    except Exception as e:
+        return jsonify({"response": f"An error occurred: {str(e)}"}), 500
 if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860)