Update app.py

app.py

@@ -264,70 +264,150 @@ def voice_to_text(audio_path):
     except Exception as e:
         return f"Audio error: {str(e)}"
 
+
 def convert_speech_to_math(text):
-    """Convert natural language to math expressions"""
+    """Convert natural language to math expressions - SIMPLE & RELIABLE"""
     if not text or text.strip() == "":
         return "0"
     
     text = text.lower().strip()
+    print(f"Original voice input: '{text}'")  # Debug
     
-    # Enhanced pattern matching with raw strings to avoid regex issues
-    patterns = [
-        (r'add\s+(\d+)\s+and\s+(\d+)', r'\1 + \2'),
-        (r'what is\s+(\d+)\s+plus\s+(\d+)', r'\1 + \2'),
-        (r'subtract\s+(\d+)\s+from\s+(\d+)', r'\2 - \1'),
-        (r'(\d+)\s+minus\s+(\d+)', r'\1 - \2'),
-        (r'multiply\s+(\d+)\s+by\s+(\d+)', r'\1 * \2'),
-        (r'(\d+)\s+times\s+(\d+)', r'\1 * \2'),
-        (r'divide\s+(\d+)\s+by\s+(\d+)', r'\1 / \2'),
-        (r'(\d+)\s+divided by\s+(\d+)', r'\1 / \2'),
-        (r'(\d+)\s+to the power of\s+(\d+)', r'\1**\2'),
-        (r'(\d+)\s+squared', r'\1**2'),
-        (r'(\d+)\s+cubed', r'\1**3'),
-        (r'square root of\s+(\d+)', r'sqrt(\1)'),
-        (r'cube root of\s+(\d+)', r'(\1)**(1/3)'),
-        (r'log of\s+(\d+)', r'log(\1)'),
-        (r'natural log of\s+(\d+)', r'ln(\1)'),
-        (r'sine of\s+(.+)', r'sin(\1)'),
-        (r'cosine of\s+(.+)', r'cos(\1)'),
-        (r'tangent of\s+(.+)', r'tan(\1)'),
-        (r'derivative of\s+(.+)', r'diff(\1, x)'),
-        (r'integral of\s+(.+)', r'integrate(\1, x)'),
-        (r'factorial of\s+(\d+)', r'factorial(\1)'),
-    ]
+    # Remove common question phrases
+    question_phrases = ["what is", "calculate", "compute", "solve", "what's", "how much is"]
+    for phrase in question_phrases:
+        text = text.replace(phrase, "").strip()
     
-    for pattern, replacement in patterns:
-        try:
-            text = re.sub(pattern, replacement, text)
-        except Exception as e:
-            print(f"Regex pattern failed: {pattern}, error: {e}")
-            continue
+    # Handle simple arithmetic directly
+    if any(op in text for op in ['+', '-', '*', '/', 'x', '×']):
+        # Replace word operators with symbols
+        text = text.replace('x', '*').replace('×', '*')
+        return text
     
-    # Word replacements (safe method)
-    replacements = {
+    # Handle spoken arithmetic patterns
+    if "plus" in text:
+        text = text.replace("plus", "+")
+    if "minus" in text:
+        text = text.replace("minus", "-")
+    if "times" in text or "multiplied by" in text:
+        text = text.replace("times", "*").replace("multiplied by", "*")
+    if "divided by" in text:
+        text = text.replace("divided by", "/")
+    
+    # Handle number words
+    number_words = {
         'zero': '0', 'one': '1', 'two': '2', 'three': '3', 'four': '4',
         'five': '5', 'six': '6', 'seven': '7', 'eight': '8', 'nine': '9',
-        'ten': '10', 'plus': '+', 'minus': '-', 'times': '*', 'multiplied by': '*',
-        'divided by': '/', 'over': '/', 'pi': 'pi', 'e': 'E'
+        'ten': '10', 'eleven': '11', 'twelve': '12', 'thirteen': '13', 
+        'fourteen': '14', 'fifteen': '15', 'sixteen': '16', 'seventeen': '17',
+        'eighteen': '18', 'nineteen': '19', 'twenty': '20', 'thirty': '30',
+        'forty': '40', 'fifty': '50', 'sixty': '60', 'seventy': '70',
+        'eighty': '80', 'ninety': '90'
     }
     
-    for word, replacement in replacements.items():
-        text = text.replace(word, replacement)
-    
-    # Clean up spaces around operators (safe method)
-    operators = ['+', '-', '*', '/', '^', '(', ')']
-    for op in operators:
-        text = text.replace(f' {op} ', op).replace(f' {op}', op).replace(f'{op} ', op)
-    
-    # Add multiplication where implied (safe method)
-    text = text.replace(')(', ')*(')
+    for word, num in number_words.items():
+        text = text.replace(word, num)
     
-    # Handle number followed by letter/variable
+    # Clean up spaces around operators
     import re
-    text = re.sub(r'(\d)([a-zA-Z(])', r'\1*\2', text)
+    text = re.sub(r'\s*([+\-*/])\s*', r'\1', text)
     
+    print(f"Converted to math: '{text}'")  # Debug
     return text
 
+def evaluate_math_safely(expression):
+    """Safely evaluate mathematical expressions"""
+    try:
+        # Handle simple arithmetic directly first
+        if any(op in expression for op in ['+', '-', '*', '/']):
+            try:
+                # Use sympy for evaluation
+                result = sp.sympify(expression)
+                return result
+            except:
+                pass
+        
+        # Try direct evaluation
+        result = sp.sympify(expression)
+        return result
+        
+    except Exception as e:
+        print(f"Evaluation error for '{expression}': {e}")
+        return None
+
+def process_math_complete(query):
+    """Complete math processing with proper error handling"""
+    try:
+        print(f"Processing query: '{query}'")
+        
+        # Convert natural language to math
+        math_expr = convert_speech_to_math(query)
+        print(f"Converted expression: '{math_expr}'")
+        
+        # Evaluate the math
+        result = evaluate_math_safely(math_expr)
+        print(f"Raw result: {result}, Type: {type(result)}")
+        
+        if result is None:
+            return "❌ Could not evaluate the expression. Please try rephrasing.", None
+        
+        # Handle boolean results (like comparisons)
+        if isinstance(result, bool):
+            if "=" in math_expr or "==" in math_expr or "!=" in math_expr:
+                return f"**Expression**: `{math_expr}`\n**Result**: `{result}`", None
+            else:
+                return "❌ Unexpected boolean result. Please check your expression.", None
+        
+        # Format successful result
+        if hasattr(result, 'evalf'):
+            numerical = result.evalf()
+            result_text = f"""
+**Input**: {query}
+**Expression**: `{math_expr}`
+**Result**: `{result}`
+**Numerical Value**: `{numerical}`
+**Method**: Symbolic Math
+"""
+        else:
+            result_text = f"""
+**Input**: {query}
+**Expression**: `{math_expr}`
+**Result**: `{result}`
+**Method**: Direct Evaluation
+"""
+        
+        return result_text, None
+        
+    except Exception as e:
+        error_msg = f"❌ Processing error: {str(e)}"
+        print(error_msg)
+        return error_msg, None
+
+def main_handler(input_type, user_input, calculus_op="differentiate", variable="x", image=None):
+    """Main handler for all math operations - UPDATED"""
+    try:
+        # Handle voice/text input
+        if input_type in ["basic", "equation"] and user_input:
+            return process_math_complete(user_input)
+        
+        # Handle calculus
+        elif input_type == "calculus" and user_input:
+            return process_calculus(calculus_op, user_input, variable), None
+        
+        # Handle image input
+        elif input_type == "image" and image is not None:
+            ocr_result, extracted_text = extract_text_from_image(image)
+            if extracted_text:
+                return process_math_complete(extracted_text)
+            return ocr_result, None
+        else:
+            return "❌ Please provide valid input", None
+            
+    except Exception as e:
+        return f"❌ Unexpected error: {str(e)}", None
+
+
+
 def evaluate_advanced_math(expression):
     """Evaluate mathematical expressions using SymPy"""
     x, y, z = symbols('x y z') # Define symbols