Upload app (3).py

app (3).py

@@ -0,0 +1,583 @@
+import sympy as sp
+import gradio as gr
+import os
+import re
+import numpy as np
+from PIL import Image
+import io
+import tempfile
+from sympy import symbols, diff, integrate, limit, sin, cos, tan, log, sqrt, factorial, Matrix, oo, E, I, pi
+
+# Try to import optional dependencies with fallbacks
+try:
+    import speech_recognition as sr
+    SPEECH_RECOGNITION_AVAILABLE = True
+except ImportError:
+    SPEECH_RECOGNITION_AVAILABLE = False
+    print("Speech recognition not available. Install with: pip install SpeechRecognition")
+
+try:
+    from gtts import gTTS
+    GTTS_AVAILABLE = True
+except ImportError:
+    GTTS_AVAILABLE = False
+    print("gTTS not available. Install with: pip install gTTS")
+
+try:
+    import pyttsx3
+    PYTTSX3_AVAILABLE = False # Initialize as False
+    try:
+        engine = pyttsx3.init()
+        engine.setProperty('rate', 150)
+        engine.setProperty('volume', 0.9)
+        PYTTSX3_AVAILABLE = True # Set to True if initialization succeeds
+    except Exception as e:
+        print(f"pyttsx3 initialization failed: {e}")
+        engine = None
+except ImportError:
+    PYTTSX3_AVAILABLE = False
+    engine = None
+    print("pyttsx3 not available. Install with: pip install pyttsx3")
+
+
+try:
+    import pytesseract
+    TESSERACT_AVAILABLE = True
+    # Point tesseract_cmd to the correct executable if needed
+    # pytesseract.pytesseract.tesseract_cmd = r'/usr/bin/tesseract' # Uncomment and modify if tesseract is not in PATH
+except ImportError:
+    TESSERACT_AVAILABLE = False
+    print("Tesseract not available. Install with: pip install pytesseract && sudo apt install tesseract-ocr")
+
+try:
+    from transformers import pipeline
+    TRANSFORMERS_AVAILABLE = True
+except ImportError:
+    TRANSFORMERS_AVAILABLE = False
+    print("Transformers not available. Install with: pip install transformers")
+
+class MathSolver:
+    def __init__(self):
+        self.ai_models_loaded = False
+        self.load_ai_models()
+
+    def load_ai_models(self):
+        """Load AI models with Hugging Face compatibility"""
+        if TRANSFORMERS_AVAILABLE:
+            try:
+                # Using a simpler model for faster loading in Colab
+                self.math_solver = pipeline(
+                    "text2text-generation",
+                    model="google/flan-t5-small",
+                    tokenizer="google/flan-t5-small"
+                )
+                self.ai_models_loaded = True
+                print("✅ AI models loaded successfully")
+            except Exception as e:
+                print(f"❌ AI model loading failed: {e}")
+                self.ai_models_loaded = False
+        else:
+            print("❌ Transformers not available for AI models")
+
+    def solve_with_ai(self, problem):
+        """Solve math problems using AI"""
+        if not self.ai_models_loaded:
+            return None
+
+        try:
+            prompt = f"Solve this math problem: {problem}. Provide the final answer."
+            result = self.math_solver(
+                prompt,
+                max_length=100,
+                num_return_sequences=1,
+                temperature=0.1
+            )
+            # Clean up potential conversational text from AI model
+            generated_text = result[0]['generated_text']
+            # Simple regex to try and isolate the math part if AI adds conversational text
+            math_part = re.search(r'([-+]?\d*\.?\d+([eE][-+]?\d+)?|\S+)', generated_text)
+            return math_part.group(0) if math_part else generated_text.strip()
+        except Exception as e:
+            print(f"AI solving error: {e}")
+            return None
+
+# Initialize math solver
+math_solver = MathSolver()
+
+def generate_tts(text, engine_choice="auto"):
+    """Generate TTS audio - Hugging Face compatible"""
+    temp_path = None
+    try:
+        # Create temp file for audio
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+        temp_path = temp_file.name
+        temp_file.close()
+
+        # Clean text for TTS
+        clean_text = re.sub(r'[**`]', '', text)
+        # Replace common symbols with words for better pronunciation
+        clean_text = clean_text.replace('+', ' plus ').replace('-', ' minus ').replace('*', ' times ').replace('/', ' divided by ').replace('**', ' to the power of ')
+        clean_text = clean_text.replace('\n', '. ')[:300]  # Limit length and replace newlines
+
+        success = False
+
+        # Try pyttsx3 first if available and preferred
+        if engine_choice in ["auto", "pyttsx3"] and PYTTSX3_AVAILABLE and engine:
+            try:
+                engine.save_to_file(clean_text, temp_path)
+                engine.runAndWait()
+                success = True
+                # print("Generated audio using pyttsx3") # Debug print
+            except Exception as e:
+                print(f"pyttsx3 failed: {e}")
+                success = False # Ensure success is False on failure
+
+        # Fallback to gTTS if pyttsx3 failed or gTTS is preferred
+        if not success and (engine_choice in ["auto", "gTTS"] or not PYTTSX3_AVAILABLE) and GTTS_AVAILABLE:
+            try:
+                tts = gTTS(text=clean_text, lang='en', slow=False)
+                tts.save(temp_path)
+                success = True
+                # print("Generated audio using gTTS") # Debug print
+            except Exception as e:
+                print(f"gTTS failed: {e}")
+                success = False
+
+        if success:
+            return temp_path
+        else:
+            print("Neither pyttsx3 nor gTTS could generate audio.")
+            return None
+
+    except Exception as e:
+        print(f"TTS generation error: {e}")
+        return None
+    finally:
+        # Clean up temp file if generation failed or was not attempted
+        if temp_path and not os.path.exists(temp_path):
+             try:
+                 os.unlink(temp_path)
+             except OSError as e:
+                 print(f"Error removing temp file {temp_path}: {e}")
+
+
+def extract_math_from_image(image_path):
+    """Extract math from image using OCR"""
+    if not TESSERACT_AVAILABLE:
+        return "OCR not available. Please install pytesseract and tesseract-ocr.", ""
+
+    if image_path is None:
+        return "No image provided.", ""
+
+    try:
+        # Ensure image_path is a string path
+        if isinstance(image_path, np.ndarray):
+             # Save numpy array to a temp file
+             pil_image = Image.fromarray(image_path.astype('uint8')).convert("RGB")
+             temp_img_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+             image_path = temp_img_file.name
+             pil_image.save(image_path)
+             temp_img_file.close()
+        elif isinstance(image_path, Image.Image):
+             # Save PIL Image to a temp file
+             temp_img_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+             image_path = temp_img_file.name
+             image_path.convert("RGB").save(image_path)
+             temp_img_file.close()
+        elif not isinstance(image_path, str):
+             return "Invalid image input type.", ""
+
+        # Configure for math symbols (might need tuning)
+        # Using --psm 6 for single uniform block of text, --oem 3 for default OCR engine
+        custom_config = r'--oem 3 --psm 6'
+        text = pytesseract.image_to_string(image_path, config=custom_config)
+
+        # Clean up temp image file if created
+        if isinstance(image_path, str) and (image_path.endswith(".png") or image_path.endswith(".jpg")): # Basic check if it's a temp file
+             try:
+                 os.unlink(image_path)
+             except OSError as e:
+                 print(f"Error removing temp image file {image_path}: {e}")
+
+
+        if text.strip():
+            # Clean OCR text
+            cleaned = clean_ocr_text(text)
+            return f"📷 Extracted: {cleaned}", cleaned
+        else:
+            return "❌ No text found in image", ""
+
+    except Exception as e:
+        return f"❌ Image processing error: {str(e)}", ""
+
+def clean_ocr_text(text):
+    """Clean OCR-extracted text"""
+    corrections = {
+        '—': '-', '–': '-', '×': '*', '÷': '/',
+        '**': '^', '``': '"', "''": '"',
+        'O': '0', 'o': '0', 'l': '1', 'I': '1',
+        '=': '==' # For equality checks
+    }
+
+    cleaned = text
+    for wrong, correct in corrections.items():
+        cleaned = cleaned.replace(wrong, correct)
+
+    cleaned = re.sub(r'\s+', ' ', cleaned).strip()
+    return cleaned
+
+def voice_to_text(audio_path):
+    """Convert voice to text"""
+    if not SPEECH_RECOGNITION_AVAILABLE:
+        return "Speech recognition not available. Please type your problem."
+
+    if audio_path is None:
+        return "No audio provided."
+
+    recognizer = sr.Recognizer()
+    try:
+        with sr.AudioFile(audio_path) as source:
+            audio_data = recognizer.record(source)
+            text = recognizer.recognize_google(audio_data)
+            return text
+    except sr.UnknownValueError:
+        return "Could not understand audio"
+    except sr.RequestError:
+        return "Speech service unavailable"
+    except Exception as e:
+        return f"Audio error: {str(e)}"
+
+def convert_speech_to_math(text):
+    """Convert natural language to math expressions"""
+    if not text or text.strip() == "":
+        return "0"
+
+    text = text.lower().strip()
+
+    # Enhanced pattern matching
+    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(\d+)\)'), # Corrected pattern for factorial
+    ]
+
+    for pattern, replacement in patterns:
+        text = re.sub(pattern, replacement, text)
+
+    # Word replacements
+    replacements = {
+        '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', 'equals': '=='
+    }
+
+    for word, replacement in replacements.items():
+        text = re.sub(r'\b' + word + r'\b', replacement, text)
+
+    # Clean up
+    text = re.sub(r'\s*([+\-*/^()])\s*', r'\1', text)
+    text = re.sub(r'(\d)([a-zA-Z(])', r'\1*\2', text) # Add multiplication sign if missing
+
+    return text
+
+def evaluate_advanced_math(expression):
+    """Evaluate mathematical expressions using SymPy"""
+    x, y, z = symbols('x y z') # Define symbols
+
+    try:
+        # Handle various operations
+        expr_lower = expression.lower()
+
+        if 'diff(' in expr_lower:
+            match = re.search(r'diff\((.*?),\s*(\w+)\)', expression)
+            if match:
+                expr_str, var = match.groups()
+                # Ensure variable is a symbol
+                return diff(sp.sympify(expr_str), symbols(var))
+
+        elif 'integrate(' in expr_lower or 'int(' in expr_lower:
+            match = re.search(r'(?:integrate|int)\((.*?),\s*(\w+)\)', expression)
+            if match:
+                expr_str, var = match.groups()
+                 # Ensure variable is a symbol
+                return integrate(sp.sympify(expr_str), symbols(var))
+
+        elif 'limit(' in expr_lower:
+            match = re.search(r'limit\((.*?),\s*(\w+)\s*->\s*([^)]+)\)', expression)
+            if match:
+                expr_str, var, point = match.groups()
+                 # Ensure variable is a symbol
+                return limit(sp.sympify(expr_str), symbols(var), sp.sympify(point))
+
+        elif 'factorial(' in expr_lower:
+            match = re.search(r'factorial\((\d+)\)', expression)
+            if match:
+                return factorial(int(match.group(1)))
+
+        # Default evaluation using sympify
+        return sp.sympify(expression)
+
+    except Exception as e:
+        raise ValueError(f"Could not evaluate: {expression}. Error: {str(e)}")
+
+def process_math(query, use_ai=True, auto_play=True, tts_engine_choice="auto"):
+    """Process math query and return result"""
+    try:
+        # Convert natural language
+        math_expr = convert_speech_to_math(query)
+
+        result = None
+        method_used = "Symbolic Math"
+
+        # Try symbolic math first
+        try:
+            result = evaluate_advanced_math(math_expr)
+        except ValueError:
+             # If symbolic math failed, try AI if enabled
+            if use_ai and math_solver.ai_models_loaded:
+                ai_result = math_solver.solve_with_ai(query)
+                if ai_result:
+                    result = ai_result
+                    method_used = "AI Model"
+                else:
+                     result = f"❌ Unable to solve '{query}' using AI. Trying basic evaluation."
+                     method_used = "Fallback Evaluation"
+
+            # Final fallback to basic evaluation if AI also failed or not used
+            if result is None or "Unable to solve" in str(result):
+                 try:
+                     # Attempt a very basic evaluation, might fail on complex expressions
+                     result = eval(math_expr)
+                     method_used = "Basic Evaluation (eval)"
+                 except:
+                      result = f"❌ Unable to solve '{query}'. Try rephrasing or check syntax."
+                      method_used = "Failed"
+
+
+        # Format result
+        if isinstance(result, sp.Basic): # Check if it's a SymPy object
+            try:
+                numerical = result.evalf()
+                result_text = f"""**Input**: `{query}`
+**Symbolic Result**: `{result}`
+**Numerical Result**: `{numerical}`
+**Method**: {method_used}"""
+            except Exception as e:
+                 # Handle cases where evalf might fail
+                 result_text = f"""**Input**: `{query}`
+**Symbolic Result**: `{result}`
+**Numerical Result**: Could not evaluate numerically ({e})
+**Method**: {method_used}"""
+        else: # For results from AI or basic eval
+            result_text = f"""**Input**: `{query}`
+**Result**: `{result}`
+**Method**: {method_used}"""
+
+        # Generate audio
+        audio_path = None
+        if auto_play and "Unable to solve" not in result_text:
+            speak_text = f"Result is {result}"
+            audio_path = generate_tts(speak_text, engine_choice=tts_engine_choice)
+
+        return result_text, audio_path
+
+    except Exception as e:
+        error_msg = f"❌ An unexpected error occurred: {str(e)}"
+        audio_path = generate_tts("Sorry, an error occurred while processing that problem.", engine_choice=tts_engine_choice) if auto_play else None
+        return error_msg, audio_path
+
+def process_all_inputs(audio=None, text_input=None, image=None, use_ai=True, auto_play=True, tts_engine_choice="auto"):
+    """Process all input types"""
+    query = ""
+    output_message = ""
+
+    # Priority: Image > Audio > Text
+    if image is not None:
+        extraction_result, extracted_text = extract_math_from_image(image)
+        output_message = extraction_result
+        if extracted_text:
+            query = extracted_text
+        else:
+            # If image processing failed or found no text, return the message and None for audio
+            audio_path = generate_tts(output_message, engine_choice=tts_engine_choice) if auto_play and "No text found" not in output_message else None
+            return output_message, audio_path
+
+    if not query and audio is not None:
+        voice_text = voice_to_text(audio)
+        if any(msg in voice_text for msg in ["not available", "not understand", "unavailable", "error"]):
+            return voice_text, None # Return error message and None for audio directly
+
+        query = voice_text
+        output_message = f"🎤 Transcribed: {query}"
+
+    if not query and text_input:
+        query = text_input
+        output_message = f"📝 Input: {query}"
+
+
+    if not query:
+        msg = "Please provide input via voice, text, or image."
+        audio_path = generate_tts(msg, engine_choice=tts_engine_choice) if auto_play else None
+        return msg, audio_path
+
+    # Process the math query
+    result_text, audio_path = process_math(query, use_ai, auto_play, tts_engine_choice)
+
+    # Combine initial message with the result
+    final_output_text = f"{output_message}\n\n{result_text}" if output_message and "Extracted:" not in output_message else result_text
+
+    # Return the output text and audio path
+    # Ensure audio_path is None if no audio was generated to satisfy Gradio's expected output format
+    return final_output_text, audio_path if audio_path and os.path.exists(audio_path) else None
+
+# Create the interface
+def create_interface():
+    global PYTTSX3_AVAILABLE, GTTS_AVAILABLE, SPEECH_RECOGNITION_AVAILABLE, TESSERACT_AVAILABLE, math_solver
+
+    with gr.Blocks(theme=gr.themes.Soft(), title="Math Solver Pro") as demo:
+        gr.Markdown("""
+        # 🧮 Math Solver Pro
+        **Solve math problems using Voice, Text, or Images with Audio Responses**
+
+        *Powered by SymPy • Hugging Face • Advanced Math Engine*
+        """)
+
+        with gr.Row():
+            with gr.Column():
+                # Input Methods
+                gr.Markdown("### 📥 Input Methods")
+
+                with gr.Tab("🎤 Voice"):
+                    audio_input = gr.Audio(
+                        sources=["microphone", "upload"],
+                        type="filepath", # Changed to filepath
+                        label="Speak Math Problem"
+                    )
+
+                with gr.Tab("📝 Text"):
+                    text_input = gr.Textbox(
+                        label="Type Math Problem",
+                        placeholder="Examples: 2+2, derivative of x^2, integrate sin(x)",
+                        lines=3
+                    )
+
+                with gr.Tab("📷 Image"):
+                    image_input = gr.Image(
+                        label="Upload Math Image",
+                        type="filepath", # Changed to filepath
+                        show_download_button=False
+                    )
+
+                # Settings
+                with gr.Accordion("⚙️ Settings", open=False):
+                    with gr.Row():
+                        use_ai = gr.Checkbox(
+                            value=math_solver.ai_models_loaded, # Reflect actual AI load status
+                            label="Use AI Models",
+                             interactive=math_solver.ai_models_loaded # Only interactive if loaded
+                        )
+                        auto_play = gr.Checkbox(
+                            value=True,
+                            label="Auto-Play Audio"
+                        )
+                    with gr.Row():
+                         tts_engine_choice = gr.Radio(
+                            ["auto", "pyttsx3", "gTTS", "None"],
+                            label="TTS Engine",
+                            value="auto",
+                            info="auto: prefers pyttsx3 if available, then gTTS. None: no audio."
+                         )
+
+                # Action Buttons
+                with gr.Row():
+                    solve_btn = gr.Button("🧠 Solve", variant="primary")
+                    clear_btn = gr.Button("🔄 Clear")
+
+            with gr.Column():
+                # Results
+                gr.Markdown("### 📊 Results")
+                output_text = gr.Markdown(
+                    label="Solution",
+                    value="Your solution will appear here..."
+                )
+
+                audio_output = gr.Audio(
+                    label="🔊 Audio Result",
+                    autoplay=True,
+                    visible=True,
+                    value=None # Initialize with None
+                )
+
+        # System Status
+        with gr.Accordion("🤖 System Status", open=False):
+            status_text = f"""
+            **Available Features:**
+            - ✅ Advanced Math Engine (SymPy)
+            - {'✅' if SPEECH_RECOGNITION_AVAILABLE else '❌'} Voice Input (Requires `SpeechRecognition`)
+            - {'✅' if TESSERACT_AVAILABLE else '❌'} Image OCR (Requires `pytesseract` and `tesseract-ocr`)
+            - {'✅' if GTTS_AVAILABLE else '❌'} Online TTS (Requires `gTTS`)
+            - {'✅' if PYTTSX3_AVAILABLE else '❌'} Offline TTS (Requires `pyttsx3`)
+            - {'✅' if math_solver.ai_models_loaded else '❌'} AI Models (Requires `transformers`)
+            """
+            gr.Markdown(status_text)
+
+        # Examples
+        with gr.Accordion("📚 Examples", open=True):
+            gr.Markdown("""
+            **Try these examples:**
+            - **Voice**: "What is 15 times 27?"
+            - **Text**: `integrate x^2 + 3x + 1 from 0 to 1`
+            - **Image**: Upload equation photo (e.g., `sqrt(16)`)
+            - **Text**: `diff(sin(x) + cos(x), x)`
+            - **Voice**: "Calculate factorial of 7"
+            """)
+
+        # Event handlers
+        solve_btn.click(
+            fn=process_all_inputs,
+            inputs=[audio_input, text_input, image_input, use_ai, auto_play, tts_engine_choice],
+            outputs=[output_text, audio_output]
+        )
+
+        def clear_all():
+            # Return None for inputs and initial values for outputs to clear the interface
+            # The temporary file will be managed by Gradio itself when the component value changes
+            return None, "", None, "Your solution will appear here...", None
+
+        clear_btn.click(
+            fn=clear_all,
+            inputs=[], # Clear button doesn't need inputs
+            outputs=[audio_input, text_input, image_input, output_text, audio_output]
+        )
+
+        text_input.submit(
+            fn=process_all_inputs,
+            inputs=[gr.State(None), text_input, gr.State(None), use_ai, auto_play, tts_engine_choice],
+            outputs=[output_text, audio_output]
+        )
+
+    return demo
+
+# Hugging Face Spaces entry point
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(share=True)