Update app.py

app.py

@@ -1,83 +1,111 @@
-import gradio as gr
+import sympy as sp
 import speech_recognition as sr
 from gtts import gTTS
 import os
-import mathparse  # Using mathparse for text-to-math conversion
 
-# Function to process math queries using sympy
+# Function to convert speech to text using CMU Sphinx
+def voice_to_text():
+    recognizer = sr.Recognizer()
+    
+    # Using the default microphone as the audio source
+    with sr.Microphone() as source:
+        print("Please speak a math expression (e.g., '2 plus 2', 'integrate x squared')...")
+        recognizer.adjust_for_ambient_noise(source)
+        audio = recognizer.listen(source)
+        
+        try:
+            # Using CMU Sphinx for offline recognition
+            text = recognizer.recognize_sphinx(audio)
+            print(f"Recognized text: {text}")
+            return text
+        except sr.UnknownValueError:
+            return "Sorry, I could not understand the audio."
+        except sr.RequestError:
+            return "Could not request results from Sphinx service."
+
+# Function to map speech to mathematical symbols
+def convert_speech_to_math(text):
+    # Mapping words to math operators
+    mapping = {
+        "plus": "+",
+        "minus": "-",
+        "times": "*",
+        "divided by": "/",
+        "squared": "**2",
+        "cube": "**3",
+        "square root of": "sqrt",
+        "integrate": "integrate",
+        "derivative of": "diff"
+    }
+
+    # Replace speech terms with math symbols
+    for word, symbol in mapping.items():
+        text = text.replace(word, symbol)
+
+    # Return the updated expression
+    return text
+
+# Function to process the math expression using SymPy
 def process_math(query):
     try:
         # Clean up the input by removing unnecessary spaces
-        query = query.replace(" ", "")  # Removing extra spaces around operators or parentheses
+        query = query.replace(" ", "")  # Removing extra spaces
         
         # Try to process the query using sympy
-        result = mathparse.parse(query)  # Use mathparse for parsing the math expression
-
+        expr = sp.sympify(query)
+        result = expr
+        
         # Convert the result to speech and save as mp3
         result_text = f"The result is: {result}"
         tts = gTTS(result_text, lang="en")
         tts.save("response.mp3")
         
-        # Return the result text for display and audio for listening
+        # Return the result text and audio file path
         return result_text, "response.mp3"
     except Exception as e:
         return f"Error: Unable to process the query. Please check the syntax. Error: {e}", None
 
-# Function to handle voice input (speech-to-text)
-def voice_to_text(audio):
-    recognizer = sr.Recognizer()
-    try:
-        with sr.AudioFile(audio) as source:
-            audio_data = recognizer.record(source)
-            text = recognizer.recognize_google(audio_data)
-            return text
-    except Exception as e:
-        return f"Error in voice recognition: {e}"
-
-# Function to convert natural language expressions into valid math expressions using mathparser
-def convert_speech_to_math(text):
-    try:
-        # Use mathparse to convert the text into a valid math expression
-        expression = mathparse.parse(text)
-        return expression
-    except Exception as e:
-        return f"Error in math conversion: {e}"
-
-# Main function to handle input and process it for math calculation (text or voice)
+# Main function for handling the math solver (either from voice or text)
 def calculator(audio=None, text_input=None):
     if audio:
-        query = voice_to_text(audio)
-        print(f"Voice Input Detected: {query}")  # Debugging: Print detected voice input
-        query = convert_speech_to_math(query)  # Convert the voice input into valid math expression
+        # Convert speech to text using CMU Sphinx
+        query = voice_to_text()
+        if query.lower() == "sorry, i could not understand the audio.":
+            return query, None
+        
+        print(f"Original Query (Voice): {query}")
+        
+        # Convert speech to math expression
+        query = convert_speech_to_math(query)
+        print(f"Converted Math Expression: {query}")
+        
     elif text_input:
+        # If text input is provided directly
         query = text_input
-        print(f"Text Input: {query}")  # Debugging: Print detected text input
+        print(f"Original Query (Text): {query}")
     else:
         return "No valid input provided.", None
-
-    # Process the math problem
+    
+    # Process the math query
     return process_math(query)
 
-# Gradio interface setup
-def start_interface():
-    # Gradio Interface with Voice Input, Text Input, and Output
-    interface = gr.Interface(
-        fn=calculator,
-        inputs=[
-            gr.Audio(type="filepath", label="Speak a Math Expression (e.g., factorial(5), differentiate x squared, integrate sin(x), matrix([[1, 2], [3, 4]]) )"),  # Voice input (required)
-            gr.Textbox(label="Or Type a Math Expression (Optional)", placeholder="Type your math expression here...")  # Optional text input
-        ],
-        outputs=[
-            "text",  # Show the text result
-            gr.Audio(label="Listen to the result")  # Provide the audio result
-        ],
-        title="Advanced Math Solver",
-        description="Solve advanced math problems including factorials, permutations, combinations, logarithms, differentiation, integration, matrices, trigonometric functions, and more. Use speech or text input for accessibility.",
-        theme="huggingface",  # Attractive theme for Gradio interface
-        live=True
-    )
+# Example usage
+if __name__ == "__main__":
+    # Get either voice or text input
+    choice = input("Do you want to use voice input or text input? (voice/text): ").strip().lower()
     
-    interface.launch()
+    if choice == "voice":
+        result_text, audio_path = calculator(audio=True)
+    elif choice == "text":
+        text_input = input("Enter a math expression (e.g., '2 + 2', 'integrate sin(x)'): ").strip()
+        result_text, audio_path = calculator(text_input=text_input)
+    else:
+        print("Invalid choice, please enter 'voice' or 'text'.")
+        exit()
 
-if __name__ == "__main__":
-    start_interface()
+    if result_text:
+        print(result_text)
+        # Optionally, you can play the audio result here (if needed)
+        os.system(f"start {audio_path}")  # For Windows, replace 'start' with 'open' for macOS
+    else:
+        print("Error: Could not process the math expression.")