Create app.py

app.py

@@ -0,0 +1,1190 @@
+
+# budget_tracker_with_voice_ocr.py
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import pytesseract
+from PIL import Image
+import speech_recognition as sr
+import io
+import base64
+import warnings
+import re
+import json
+import os
+import tempfile
+from transformers import pipeline
+import torch
+import pytesseract
+import os
+
+
+warnings.filterwarnings('ignore')
+
+# Set Tesseract path (update this path according to your system)
+# For Windows: r"C:\Program Files\Tesseract-OCR\tesseract.exe"
+# For Mac: "/usr/local/bin/tesseract"
+# For Linux: "/usr/bin/tesseract"
+try:
+    # You can set your Tesseract path here
+    TESSERACT_PATH = os.getenv("TESSERACT_PATH", r'/usr/bin/tesseract')  # Default for Linux
+    pytesseract.pytesseract.tesseract_cmd = TESSERACT_PATH
+except:
+    pass  # Use default path
+
+
+
+# Initialize session state for data persistence
+def initialize_session_state():
+    """Initialize all session state variables"""
+    try:
+        if 'expenses' not in st.session_state:
+            st.session_state.expenses = pd.DataFrame(columns=['date', 'amount', 'category', 'description', 'receipt_image'])
+        if 'budgets' not in st.session_state:
+            st.session_state.budgets = pd.DataFrame(columns=['category', 'budget_amount', 'period'])
+        if 'savings_goals' not in st.session_state:
+            st.session_state.savings_goals = pd.DataFrame(columns=['goal_name', 'target_amount', 'current_amount', 'target_date'])
+        if 'notifications' not in st.session_state:
+            st.session_state.notifications = []
+        if 'whisper_model' not in st.session_state:
+            st.session_state.whisper_model = None
+        return True
+    except Exception as e:
+        st.error(f"Error initializing session state: {str(e)}")
+        return False
+
+# Voice Recognition with Whisper (Corrected Implementation)
+def load_whisper_model():
+    """Load Whisper model for speech recognition"""
+    try:
+        if st.session_state.whisper_model is None:
+            with st.spinner("Loading Whisper model... This may take a moment."):
+                st.session_state.whisper_model = pipeline(
+                    "automatic-speech-recognition",
+                    model="openai/whisper-tiny",  # Using tiny model for faster loading
+                    chunk_length_s=30,
+                )
+        return st.session_state.whisper_model
+    except Exception as e:
+        st.error(f"Error loading Whisper model: {str(e)}")
+        return None
+
+def transcribe_audio_with_whisper(audio_file_path):
+    """Transcribe audio using Whisper model"""
+    try:
+        model = load_whisper_model()
+        if model is None:
+            return None
+            
+        with st.spinner("Transcribing audio..."):
+            output = model(
+                audio_file_path,
+                generate_kwargs={"task": "transcribe"},
+                batch_size=8,
+                return_timestamps=False,
+            )
+            return output["text"]
+    except Exception as e:
+        st.error(f"Error in transcription: {str(e)}")
+        return None
+
+def transcribe_audio_with_google(audio_file_path):
+    """Fallback: Transcribe audio using Google Speech Recognition"""
+    try:
+        recognizer = sr.Recognizer()
+        with sr.AudioFile(audio_file_path) as source:
+            audio = recognizer.record(source)
+            text = recognizer.recognize_google(audio)
+            return text
+    except Exception as e:
+        st.error(f"Google Speech Recognition error: {str(e)}")
+        return None
+
+def voice_expense_recording():
+    """
+    Function to record expense using voice input
+    LLM Needed: NO - Uses Whisper/GSR for speech recognition
+    Could use LLM for better natural language understanding
+    """
+    try:
+        st.subheader("🎤 Voice Expense Recording")
+        
+        # Audio input options
+        audio_option = st.radio("Choose audio input method:", 
+                               ["Microphone (Real-time)", "Upload Audio File"])
+        
+        if audio_option == "Microphone (Real-time)":
+            # Check if microphone is available
+            try:
+                recognizer = sr.Recognizer()
+                mic_available = True
+            except:
+                mic_available = False
+                st.warning("Microphone not available. Please check your device settings.")
+            
+            if mic_available and st.button("🎙️ Start Voice Recording"):
+                try:
+                    with sr.Microphone() as source:
+                        st.info("🎤 Listening... Please speak your expense (e.g., 'I spent 500 rupees on groceries')")
+                        # Adjust for ambient noise
+                        recognizer.adjust_for_ambient_noise(source, duration=1)
+                        audio = recognizer.listen(source, timeout=10)
+                        
+                        # Save audio to temporary file for processing
+                        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
+                            with open(tmp_file.name, "wb") as f:
+                                f.write(audio.get_wav_data())
+                            temp_filename = tmp_file.name
+                        
+                        # Try Whisper first, fallback to Google
+                        text = transcribe_audio_with_whisper(temp_filename)
+                        if text is None:
+                            text = transcribe_audio_with_google(temp_filename)
+                        
+                        # Clean up temporary file
+                        os.unlink(temp_filename)
+                        
+                        if text:
+                            st.success(f"✅ Recognized: {text}")
+                            process_voice_text(text)
+                        else:
+                            st.error("❌ Failed to transcribe audio")
+                            
+                except sr.WaitTimeoutError:
+                    st.error("⏰ Timeout: No speech detected within 10 seconds")
+                except sr.UnknownValueError:
+                    st.error("🤔 Could not understand audio. Please try again.")
+                except sr.RequestError as e:
+                    st.error(f"🌐 Could not request results: {e}")
+                except Exception as e:
+                    st.error(f"❌ Error processing voice input: {str(e)}")
+        
+        else:  # Upload Audio File
+            uploaded_audio = st.file_uploader("Upload Audio File", type=['wav', 'mp3', 'm4a'])
+            
+            if uploaded_audio is not None:
+                if st.button("🔊 Process Audio File"):
+                    try:
+                        # Save uploaded file temporarily
+                        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(uploaded_audio.name)[1]) as tmp_file:
+                            tmp_file.write(uploaded_audio.getvalue())
+                            temp_filename = tmp_file.name
+                        
+                        # Process audio file
+                        with st.spinner("Processing audio file..."):
+                            # Try Whisper first, fallback to Google
+                            text = transcribe_audio_with_whisper(temp_filename)
+                            if text is None:
+                                text = transcribe_audio_with_google(temp_filename)
+                            
+                            # Clean up temporary file
+                            os.unlink(temp_filename)
+                            
+                            if text:
+                                st.success(f"✅ Transcribed: {text}")
+                                process_voice_text(text)
+                            else:
+                                st.error("❌ Failed to transcribe audio file")
+                                
+                    except Exception as e:
+                        st.error(f"❌ Error processing audio file: {str(e)}")
+        
+        # Instructions
+        st.info("💡 Tip: Say something like 'I spent 500 rupees on groceries at Big Bazaar'")
+        
+    except Exception as e:
+        st.error(f"❌ Critical error in voice recording: {str(e)}")
+
+def process_voice_text(text):
+    """Process transcribed voice text to extract expense details"""
+    try:
+        # Enhanced parsing logic
+        st.info("🔄 Processing voice input...")
+        amount = 0
+        category = "Other"
+        description = text
+        
+        # Enhanced category detection
+        categories = {
+            'Food': ['food', 'groceries', 'restaurant', 'cafe', 'meal', 'lunch', 'dinner', 'breakfast', 'dhaba', 'hotel'],
+            'Transport': ['transport', 'travel', 'taxi', 'uber', 'ola', 'bus', 'train', 'flight', 'fuel', 'petrol', 'diesel', 'auto'],
+            'Shopping': ['shopping', 'clothes', 'electronics', 'purchase', 'buy', 'mall', 'store', 'market'],
+            'Entertainment': ['entertainment', 'movie', 'cinema', 'game', 'fun', 'party', 'netflix', 'spotify'],
+            'Bills': ['bill', 'electricity', 'water', 'internet', 'phone', 'rent', 'insurance', 'subscription'],
+            'Health': ['medicine', 'doctor', 'hospital', 'pharmacy', 'health', 'medical'],
+            'Education': ['education', 'school', 'college', 'books', 'course', 'tuition', 'study']
+        }
+        
+        text_lower = text.lower()
+        for cat, keywords in categories.items():
+            if any(keyword in text_lower for keyword in keywords):
+                category = cat
+                break
+        
+        # Extract numbers for amount using regex
+        amount_pattern = r'(?:$|\$|rs|rupees?|dollars?)\s*(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s*(?:$|\$|rs|rupees?|dollars?)'
+
+        # amount_pattern = r'(?:$|rs|rupees?)\s*(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s*(?:$|rs|rupees?)'
+        matches = re.findall(amount_pattern, text_lower)
+        if matches:
+            for match in matches:
+                for group in match:
+                    if group and (group.replace('.', '').isdigit()):
+                        amount = float(group)
+                        break
+                if amount > 0:
+                    break
+        
+        # Fallback: look for any number
+        if amount == 0:
+            numbers = re.findall(r'\d+(?:\.\d+)?', text)
+            if numbers:
+                amount = float(numbers[0])
+        
+        # Save to expenses
+        new_expense = pd.DataFrame({
+            'date': [datetime.now().strftime('%Y-%m-%d')],
+            'amount': [amount],
+            'category': [category],
+            'description': [description],
+            'receipt_image': ['']
+        })
+        st.session_state.expenses = pd.concat([st.session_state.expenses, new_expense], ignore_index=True)
+        st.success(f"✅ Expense logged: ${amount:.2f} for {category}")
+
+        
+        # Check budget alerts
+        check_budget_alerts(amount, category)
+        
+    except Exception as e:
+        st.error(f"❌ Error processing voice text: {str(e)}")
+
+# OCR Processing (Corrected Implementation)
+class OCRExtractor:
+    def __init__(self):
+        pass
+    
+    def extract_text_from_image(self, image_input):
+        """Extract text from image using Tesseract OCR"""
+        try:
+            # Handle different input types
+            if hasattr(image_input, 'read'):
+                # Uploaded file
+                image = Image.open(image_input)
+            elif isinstance(image_input, str):
+                # File path
+                image = Image.open(image_input)
+            else:
+                # PIL Image
+                image = image_input
+            
+            # Convert to RGB if necessary
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Extract text with multiple languages support
+            custom_config = r'--oem 3 --psm 6 -l eng'
+            text = pytesseract.image_to_string(image, config=custom_config)
+            
+            return text.strip()
+        except Exception as e:
+            st.error(f"OCR Error: {e}")
+            return None
+    
+    def extract_structured_data(self, image_input):
+        """Extract structured data from receipt image"""
+        try:
+            text = self.extract_text_from_image(image_input)
+            if not text:
+                return None
+            
+            # Basic structure extraction
+            lines = [line.strip() for line in text.split('\n') if line.strip()]
+            
+            return {
+                'raw_text': text,
+                'lines': lines,
+                'extracted_at': str(pd.Timestamp.now())
+            }
+        except Exception as e:
+            st.error(f"Error extracting structured data: {e}")
+            return None
+    
+    def preprocess_image(self, image):
+        """Preprocess image for better OCR results"""
+        try:
+            # Convert to grayscale
+            if image.mode != 'L':
+                image = image.convert('L')
+            
+            # You can add more preprocessing steps here
+            # like noise reduction, contrast enhancement, etc.
+            
+            return image
+        except Exception as e:
+            st.error(f"Error preprocessing image: {e}")
+            return image
+
+def ocr_receipt_processing():
+    """
+    Function to process receipt images using OCR
+    LLM Needed: NO - Uses Tesseract OCR for text extraction
+    Could use LLM for better data parsing and categorization
+    """
+    try:
+        st.subheader("📸 Receipt OCR Processing")
+        
+        uploaded_file = st.file_uploader("Upload Receipt Image", type=['jpg', 'jpeg', 'png'])
+        
+        if uploaded_file is not None:
+            try:
+                image = Image.open(uploaded_file)
+                st.image(image, caption="📸 Uploaded Receipt", use_container_width=True)
+                
+                if st.button("🔍 Process Receipt"):
+                    # Initialize OCR extractor
+                    ocr_extractor = OCRExtractor()
+                    
+                    # Use Tesseract OCR
+                    try:
+                        # Preprocess image for better results
+                        processed_image = ocr_extractor.preprocess_image(image)
+                        
+                        # Extract text
+                        extracted_text = ocr_extractor.extract_text_from_image(processed_image)
+                        
+                        if extracted_text:
+                            st.text_area("📄 Extracted Text", extracted_text, height=200)
+                            
+                            # Parse receipt data
+                            amount = 0
+                            category = "Other"
+                            description = "Receipt expense"
+                            
+                            # Extract amount with multiple patterns
+                            amount_patterns = [
+                                r'[$$€£]\s*(\d+(?:\.\d+)?)',
+                                r'(\d+(?:\.\d+)?)\s*[$$€£]',
+                                r'(?:total|amount|paid|grand total).*?(\d+(?:\.\d+)?)',
+                                r'(?:bill|invoice).*?(\d+(?:\.\d+)?)'
+                            ]
+                            
+                            for pattern in amount_patterns:
+                                matches = re.findall(pattern, extracted_text.lower(), re.IGNORECASE)
+                                if matches:
+                                    for match in matches:
+                                        if isinstance(match, tuple):
+                                            for group in match:
+                                                if group and (group.replace('.', '').isdigit()):
+                                                    amount = float(group)
+                                                    break
+                                        elif match.replace('.', '').isdigit():
+                                            amount = float(match)
+                                            break
+                                    if amount > 0:
+                                        break
+                            
+                            # Enhanced category detection
+                            categories_keywords = {
+                                'Food': ['restaurant', 'cafe', 'grocery', 'food', 'meal', 'supermarket', 'big bazaar', 'dmart', 'walmart'],
+                                'Transport': ['taxi', 'uber', 'ola', 'fuel', 'petrol', 'bus', 'train', 'airport', 'parking'],
+                                'Shopping': ['mall', 'store', 'shop', 'purchase', 'clothes', 'electronics', 'amazon', 'flipkart'],
+                                'Entertainment': ['movie', 'cinema', 'game', 'entertainment', 'theatre', 'netflix'],
+                                'Bills': ['electricity', 'water', 'internet', 'phone', 'rent', 'subscription', 'bill'],
+                                'Health': ['pharmacy', 'medicine', 'doctor', 'hospital', 'medical', 'apollo', 'apollo'],
+                                'Education': ['school', 'college', 'books', 'stationery', 'tution', 'course']
+                            }
+                            
+                            text_lower = extracted_text.lower()
+                            for cat, keywords in categories_keywords.items():
+                                if any(keyword in text_lower for keyword in keywords):
+                                    category = cat
+                                    break
+                            
+                            # Save to expenses with image data
+                            image_data = f"data:image/png;base64,{base64.b64encode(uploaded_file.getvalue()).decode()}"
+                            new_expense = pd.DataFrame({
+                                'date': [datetime.now().strftime('%Y-%m-%d')],
+                                'amount': [amount],
+                                'category': [category],
+                                'description': [description],
+                                'receipt_image': [image_data]
+                            })
+                            st.session_state.expenses = pd.concat([st.session_state.expenses, new_expense], ignore_index=True)
+                            st.success(f"✅ Receipt processed successfully: ${amount:.2f} for {category}")
+                            
+                            # Check budget alerts
+                            check_budget_alerts(amount, category)
+                        else:
+                            st.error("❌ Could not extract text from image. Please try a clearer image.")
+                            
+                    except Exception as e:
+                        st.error(f"❌ OCR processing failed: {str(e)}")
+                        st.info("💡 Make sure Tesseract OCR is properly installed on your system")
+                
+            except Exception as e:
+                st.error(f"❌ Error processing image: {str(e)}")
+        else:
+            st.info("📤 Please upload a receipt image (JPG, JPEG, PNG)")
+            
+    except Exception as e:
+        st.error(f"❌ Critical error in OCR processing: {str(e)}")
+
+def create_budget():
+    """
+    Function to create and manage budgets
+    LLM Needed: NO - Simple form-based input
+    Could use LLM for budget recommendations based on spending patterns
+    """
+    try:
+        st.subheader("💰 Create Budget")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            predefined_categories = ["Food", "Transport", "Shopping", "Entertainment", "Bills", "Health", "Education", "Other"]
+            category_type = st.radio("Category Type", ["Predefined", "Custom"])
+            if category_type == "Predefined":
+                category = st.selectbox("Category", predefined_categories)
+            else:
+                category = st.text_input("Enter custom category")
+        
+        with col2:
+            budget_amount = st.number_input("Budget Amount ($)", min_value=0.0, step=100.0, value=1000.0)
+            period = st.selectbox("Period", ["Monthly", "Weekly", "Custom"])
+        
+        if st.button("📊 Set Budget"):
+            if category and budget_amount > 0:
+                try:
+                    # Check if budget already exists for this category
+                    existing_budget = st.session_state.budgets[
+                        st.session_state.budgets['category'] == category
+                    ]
+                    
+                    if not existing_budget.empty:
+                        # Update existing budget
+                        st.session_state.budgets.loc[
+                            st.session_state.budgets['category'] == category, 'budget_amount'
+                        ] = budget_amount
+                        st.session_state.budgets.loc[
+                            st.session_state.budgets['category'] == category, 'period'
+                        ] = period
+                        st.success(f"🔄 Budget updated: ${budget_amount:.2f} for {category}")
+                    else:
+                        # Add new budget
+                        new_budget = pd.DataFrame({
+                            'category': [category],
+                            'budget_amount': [budget_amount],
+                            'period': [period]
+                        })
+                        st.session_state.budgets = pd.concat([st.session_state.budgets, new_budget], ignore_index=True)
+                        st.success(f"✅ Budget set: ${budget_amount:.2f} for {category}")
+                except Exception as e:
+                    st.error(f"❌ Error setting budget: {str(e)}")
+            else:
+                st.error("⚠️ Please enter valid category and amount")
+        
+        # Display existing budgets
+        if not st.session_state.budgets.empty:
+            st.subheader("📊 Current Budgets")
+            st.dataframe(st.session_state.budgets)
+            
+            # Option to delete budgets
+            if st.checkbox("🗑️ Show delete options"):
+                budget_to_delete = st.selectbox("Select budget to delete", 
+                                               st.session_state.budgets['category'].tolist())
+                if st.button("🗑️ Delete Budget"):
+                    st.session_state.budgets = st.session_state.budgets[
+                        st.session_state.budgets['category'] != budget_to_delete
+                    ]
+                    st.success(f"✅ Budget for {budget_to_delete} deleted")
+        else:
+            st.info("📝 No budgets set yet. Create your first budget!")
+            
+    except Exception as e:
+        st.error(f"❌ Critical error in budget creation: {str(e)}")
+
+def set_savings_goals():
+    """
+    Function to set and track savings goals
+    LLM Needed: NO - Simple goal tracking
+    Could use LLM for personalized savings recommendations
+    """
+    try:
+        st.subheader("🎯 Savings Goals")
+        
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            goal_name = st.text_input("Goal Name", placeholder="e.g., Vacation, Emergency Fund")
+        with col2:
+            target_amount = st.number_input("Target Amount ($)", min_value=0.0, step=1000.0, value=10000.0)
+        with col3:
+            target_date = st.date_input("Target Date", 
+                                      value=datetime.now() + timedelta(days=30))
+        
+        if st.button("🎯 Set Goal"):
+            if goal_name and target_amount > 0:
+                try:
+                    new_goal = pd.DataFrame({
+                        'goal_name': [goal_name],
+                        'target_amount': [target_amount],
+                        'current_amount': [0.0],
+                        'target_date': [target_date]
+                    })
+                    st.session_state.savings_goals = pd.concat([st.session_state.savings_goals, new_goal], ignore_index=True)
+                    st.success(f"✅ Savings goal '{goal_name}' set!")
+                    st.balloons()
+                except Exception as e:
+                    st.error(f"❌ Error setting goal: {str(e)}")
+            else:
+                st.error("⚠️ Please enter valid goal name and target amount")
+        
+        # Display existing goals
+        if not st.session_state.savings_goals.empty:
+            st.subheader("🏆 Current Goals")
+            
+            for idx, goal in st.session_state.savings_goals.iterrows():
+                try:
+                    progress = (goal['current_amount'] / goal['target_amount']) * 100 if goal['target_amount'] > 0 else 0
+                    days_left = (goal['target_date'] - datetime.now().date()).days
+                    
+                    st.write(f"**{goal['goal_name']}**")
+                    st.progress(min(progress/100, 1.0))
+                    st.write(f"💰 ${goal['current_amount']:.2f} / ${goal['target_amount']:.2f} ({progress:.1f}%)")
+                    st.write(f"📅 Target Date: {goal['target_date']} ({days_left} days left)")
+                    
+                    # Add to current savings
+                    add_amount = st.number_input(f"Add to {goal['goal_name']}", 
+                                               min_value=0.0, step=100.0, key=f"add_{idx}")
+                    if st.button(f"➕ Add to {goal['goal_name']}", key=f"btn_{idx}"):
+                        if add_amount > 0:
+                            st.session_state.savings_goals.at[idx, 'current_amount'] += add_amount
+                            st.success(f"✅ Added ${add_amount:.2f} to {goal['goal_name']}")
+                            st.rerun()
+                    
+                    st.write("---")
+                except Exception as e:
+                    st.error(f"❌ Error displaying goal: {str(e)}")
+        else:
+            st.info("📝 No savings goals set yet. Create your first goal!")
+            
+    except Exception as e:
+        st.error(f"❌ Critical error in savings goals: {str(e)}")
+
+def spending_categorization():
+    """
+    Function to categorize and review spending
+    LLM Needed: NO - Rule-based categorization
+    Could use LLM for smarter automatic categorization
+    """
+    try:
+        st.subheader("🏷️ Spending Categorization")
+        
+        if not st.session_state.expenses.empty:
+            # Display expenses that need categorization
+            uncategorized = st.session_state.expenses[st.session_state.expenses['category'] == 'Other']
+            if not uncategorized.empty:
+                st.write("📝 Uncategorized Expenses:")
+                for idx, expense in uncategorized.iterrows():
+                    try:
+                        st.write(f"📅 {expense['date']} | ${expense['amount']:.2f} | {expense['description']}")
+                        predefined_categories = ["Food", "Transport", "Shopping", "Entertainment", "Bills", "Health", "Education", "Other"]
+                        new_category = st.selectbox(f"Re-categorize", predefined_categories, 
+                                                  key=f"cat_{idx}")
+                        if st.button(f"🔄 Update Category {idx}"):
+                            if new_category and new_category != 'Other':
+                                st.session_state.expenses.at[idx, 'category'] = new_category
+                                st.success(f"✅ Category updated to {new_category}!")
+                                st.rerun()
+                    except Exception as e:
+                        st.error(f"❌ Error updating category: {str(e)}")
+                st.write("---")
+            
+            # Show all expenses with filter options
+            st.subheader("📋 All Expenses")
+            
+            # Filters
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                category_filter = st.selectbox("Filter by Category", 
+                                             ["All"] + list(st.session_state.expenses['category'].unique()))
+            with col2:
+                date_filter = st.selectbox("Date Range", ["All", "Last 7 days", "Last 30 days", "This month"])
+            with col3:
+                min_amount = st.number_input("Min Amount", min_value=0.0, step=10.0)
+                max_amount = st.number_input("Max Amount", min_value=0.0, 
+                                           value=float(st.session_state.expenses['amount'].max()) if not st.session_state.expenses.empty else 10000.0)
+            
+            # Apply filters
+            filtered_expenses = st.session_state.expenses.copy()
+            
+            if category_filter != "All":
+                filtered_expenses = filtered_expenses[filtered_expenses['category'] == category_filter]
+            
+            if date_filter == "Last 7 days":
+                cutoff_date = (datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d')
+                filtered_expenses = filtered_expenses[filtered_expenses['date'] >= cutoff_date]
+            elif date_filter == "Last 30 days":
+                cutoff_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
+                filtered_expenses = filtered_expenses[filtered_expenses['date'] >= cutoff_date]
+            elif date_filter == "This month":
+                current_month = datetime.now().strftime('%Y-%m')
+                filtered_expenses = filtered_expenses[filtered_expenses['date'].str.startswith(current_month)]
+            
+            filtered_expenses = filtered_expenses[
+                (filtered_expenses['amount'] >= min_amount) & 
+                (filtered_expenses['amount'] <= max_amount)
+            ]
+            
+            if not filtered_expenses.empty:
+                st.dataframe(filtered_expenses[['date', 'amount', 'category', 'description']])
+                
+                # Summary statistics
+                st.subheader("📊 Summary")
+                total_spent = filtered_expenses['amount'].sum()
+                avg_spent = filtered_expenses['amount'].mean()
+                st.metric("Total Spent", f"${total_spent:.2f}")
+
+                st.metric("Average Expense", f"${avg_spent:.2f}")
+
+            else:
+                st.info("🔍 No expenses match the current filters")
+        else:
+            st.info("📝 No expenses recorded yet. Start by adding expenses through voice or receipt scanning!")
+            
+    except Exception as e:
+        st.error(f"❌ Critical error in spending categorization: {str(e)}")
+
+def check_budget_alerts(amount, category):
+    """
+    Helper function to check budget alerts
+    """
+    try:
+        if not st.session_state.budgets.empty:
+            category_budget = st.session_state.budgets[st.session_state.budgets['category'] == category]
+            if not category_budget.empty:
+                budget_amount = category_budget.iloc[0]['budget_amount']
+                current_spending = st.session_state.expenses[
+                    st.session_state.expenses['category'] == category
+                ]['amount'].sum()
+                
+                if current_spending > budget_amount:
+                    alert_msg = f"🚨 OVERSPENT: {category} - ${current_spending:.2f}/${budget_amount:.2f}"
+
+
+                    if alert_msg not in st.session_state.notifications:
+                        st.session_state.notifications.append(alert_msg)
+                elif current_spending > budget_amount * 0.8:  # 80% threshold
+                    alert_msg = f"⚠️ WARNING: {category} - ${current_spending:.2f}/${budget_amount:.2f} ({((current_spending/budget_amount)*100):.1f}%)"
+
+
+                    if alert_msg not in st.session_state.notifications:
+                        st.session_state.notifications.append(alert_msg)
+    except Exception as e:
+        st.error(f"❌ Error checking budget alerts: {str(e)}")
+
+def alerts_and_notifications():
+    """
+    Function to check and display budget alerts
+    LLM Needed: NO - Simple threshold checking
+    Could use LLM for personalized alert messages
+    """
+    try:
+        st.subheader("🔔 Budget Alerts & Notifications")
+        
+        # Clear notifications button
+        if st.session_state.notifications:
+            if st.button("🧹 Clear All Notifications"):
+                st.session_state.notifications = []
+                st.rerun()
+        
+        # Check for new alerts
+        if not st.session_state.expenses.empty and not st.session_state.budgets.empty:
+            try:
+                # Calculate spending by category
+                spending_by_category = st.session_state.expenses.groupby('category')['amount'].sum().reset_index()
+                
+                alerts = []
+                for _, budget in st.session_state.budgets.iterrows():
+                    category_spending = spending_by_category[spending_by_category['category'] == budget['category']]
+                    if not category_spending.empty:
+                        spent = category_spending.iloc[0]['amount']
+                        budget_amount = budget['budget_amount']
+                        
+                        if spent > budget_amount:
+                            alerts.append(f"🚨 OVERSPENT: {budget['category']} - ${spent:.2f}/${budget_amount:.2f} ({((spent/budget_amount)*100):.1f}%)")
+
+
+                        elif spent > budget_amount * 0.8:  # 80% threshold
+                            alerts.append(f"⚠️ WARNING: {budget['category']} - ${spent:.2f}/${budget_amount:.2f} ({((spent/budget_amount)*100):.1f}%)")
+
+
+                
+                # Display alerts
+                if alerts:
+                    for alert in alerts:
+                        st.warning(alert)
+                        if alert not in st.session_state.notifications:
+                            st.session_state.notifications.append(alert)
+                else:
+                    st.success("✅ All budgets are within limits!")
+                    
+            except Exception as e:
+                st.error(f"❌ Error calculating alerts: {str(e)}")
+        else:
+            st.info("📝 Set up budgets and record expenses to see alerts")
+        
+        # Display all notifications
+        if st.session_state.notifications:
+            st.subheader("📜 Recent Notifications")
+            for notification in reversed(st.session_state.notifications[-10:]):  # Show last 10
+                st.info(notification)
+        else:
+            st.info("📭 No notifications yet")
+            
+    except Exception as e:
+        st.error(f"❌ Critical error in alerts system: {str(e)}")
+
+def visualizations_and_summaries():
+    """
+    Function to create charts and summaries
+    LLM Needed: NO - Standard data visualization
+    Could use LLM for generating insights and summaries
+    """
+    try:
+        st.subheader("📊 Financial Visualizations")
+        
+        if not st.session_state.expenses.empty:
+            try:
+                # Spending by category pie chart
+                spending_by_category = st.session_state.expenses.groupby('category')['amount'].sum()
+                
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.write("💰 Spending by Category")
+                    if len(spending_by_category) > 0:
+                        fig1 = px.pie(values=spending_by_category.values, names=spending_by_category.index,
+                                    title="Expense Distribution by Category")
+                        st.plotly_chart(fig1, use_container_width=True)
+                    else:
+                        st.info("No spending data to visualize")
+                
+                with col2:
+                    st.write("📈 Spending Trend")
+                    daily_spending = st.session_state.expenses.groupby('date')['amount'].sum().reset_index()
+                    if len(daily_spending) > 1:
+                        fig2 = px.line(daily_spending, x='date', y='amount', 
+                                     title='Daily Spending Trend')
+                        fig2.update_xaxes(type='category')
+                        st.plotly_chart(fig2, use_container_width=True)
+                    else:
+                        st.info("Need more data points for trend analysis")
+                
+                # Monthly summary
+                st.subheader("📋 Monthly Summary")
+                current_month = datetime.now().strftime('%Y-%m')
+                monthly_expenses = st.session_state.expenses[
+                    st.session_state.expenses['date'].str.startswith(current_month)
+                ]
+                
+                if not monthly_expenses.empty:
+                    total_spent = monthly_expenses['amount'].sum()
+                    st.metric("Total Monthly Spending", f"${total_spent:.2f}")
+
+                    
+                    category_summary = monthly_expenses.groupby('category')['amount'].sum().reset_index()
+                    fig3 = px.bar(category_summary, x='category', y='amount', 
+                                title='Monthly Spending by Category')
+                    st.plotly_chart(fig3, use_container_width=True)
+                    
+                    st.dataframe(category_summary)
+                else:
+                    st.info("No expenses recorded this month.")
+                    
+                # Budget vs Actual comparison
+                if not st.session_state.budgets.empty:
+                    st.subheader("⚖️ Budget vs Actual Comparison")
+                    budget_comparison = []
+                    for _, budget in st.session_state.budgets.iterrows():
+                        actual_spent = st.session_state.expenses[
+                            st.session_state.expenses['category'] == budget['category']
+                        ]['amount'].sum()
+                        budget_comparison.append({
+                            'Category': budget['category'],
+                            'Budget': budget['budget_amount'],
+                            'Actual': actual_spent,
+                            'Difference': budget['budget_amount'] - actual_spent
+                        })
+                    
+                    if budget_comparison:
+                        comparison_df = pd.DataFrame(budget_comparison)
+                        st.dataframe(comparison_df)
+                        
+                        # Visualization
+                        fig4 = go.Figure()
+                        fig4.add_trace(go.Bar(name='Budget', x=comparison_df['Category'], y=comparison_df['Budget']))
+                        fig4.add_trace(go.Bar(name='Actual', x=comparison_df['Category'], y=comparison_df['Actual']))
+                        fig4.update_layout(title="Budget vs Actual Spending", barmode='group')
+                        st.plotly_chart(fig4, use_container_width=True)
+                    
+            except Exception as e:
+                st.error(f"❌ Error creating visualizations: {str(e)}")
+        else:
+            st.info("📝 No data to visualize yet. Start by recording expenses!")
+            
+    except Exception as e:
+        st.error(f"❌ Critical error in visualizations: {str(e)}")
+
+def receipt_management():
+    """
+    Function to manage and view stored receipts
+    LLM Needed: NO - Simple storage and retrieval
+    Could use LLM for receipt categorization and insights
+    """
+    try:
+        st.subheader("🧾 Receipt Management")
+        
+        if not st.session_state.expenses.empty:
+            receipts = st.session_state.expenses[st.session_state.expenses['receipt_image'] != '']
+            if not receipts.empty:
+                st.write(f"📁 Found {len(receipts)} receipts")
+                
+                # Search functionality
+                search_term = st.text_input("���� Search receipts by description or category")
+                if search_term:
+                    receipts = receipts[
+                        receipts['description'].str.contains(search_term, case=False) |
+                        receipts['category'].str.contains(search_term, case=False)
+                    ]
+                    st.write(f"🔍 Found {len(receipts)} matching receipts")
+                
+                # Sort options
+                sort_option = st.selectbox("Sort by", ["Date (Newest)", "Date (Oldest)", "Amount (High to Low)", "Amount (Low to High)"])
+                
+                if sort_option == "Date (Newest)":
+                    receipts = receipts.sort_values('date', ascending=False)
+                elif sort_option == "Date (Oldest)":
+                    receipts = receipts.sort_values('date', ascending=True)
+                elif sort_option == "Amount (High to Low)":
+                    receipts = receipts.sort_values('amount', ascending=False)
+                elif sort_option == "Amount (Low to High)":
+                    receipts = receipts.sort_values('amount', ascending=True)
+                
+                # Display receipts in a grid
+                if not receipts.empty:
+                    cols = st.columns(3)
+                    for idx, (i, receipt) in enumerate(receipts.iterrows()):
+                        try:
+                            with cols[idx % 3]:
+                                st.write(f"**📅 {receipt['date']}**")
+                                st.write(f"💰 ${receipt['amount']:.2f}")
+
+                                st.write(f"🏷️ {receipt['category']}")
+                                if receipt['receipt_image'].startswith('data:image'):
+                                    # Display base64 image
+                                    st.image(receipt['receipt_image'], width=200)
+                                st.write(f"📝 {receipt['description'][:50]}...")
+                                st.write("---")
+                        except Exception as e:
+                            st.error(f"❌ Error displaying receipt: {str(e)}")
+                else:
+                    st.info("🔍 No receipts match your search criteria")
+            else:
+                st.info("📝 No receipts uploaded yet. Upload receipts through the OCR feature!")
+        else:
+            st.info("📝 No expenses recorded yet. Start by recording expenses!")
+            
+    except Exception as e:
+        st.error(f"❌ Critical error in receipt management: {str(e)}")
+
+def data_security_and_privacy():
+    """
+    Function to handle data security (simulated)
+    LLM Needed: NO - Just UI for privacy settings
+    """
+    try:
+        st.subheader("🔒 Data Security & Privacy")
+        
+        st.write("🛡️ Your financial data is stored locally and never shared with third parties.")
+        st.write("🔐 All data is encrypted and protected according to privacy regulations.")
+        
+        # Security settings
+        st.subheader("⚙️ Security Settings")
+        
+        if st.checkbox("Enable Data Encryption", value=True):
+            st.success("✅ Data encryption is enabled!")
+        
+        if st.checkbox("Enable Automatic Backups"):
+            backup_frequency = st.selectbox("Backup Frequency", ["Daily", "Weekly", "Monthly"])
+            st.info(f"📅 Automatic backups will run {backup_frequency.lower()}")
+        
+        # Data export
+        st.subheader("📤 Data Export")
+        if st.button("💾 Export All Data"):
+            try:
+                export_data = {
+                    'expenses': st.session_state.expenses.to_dict('records') if not st.session_state.expenses.empty else [],
+                    'budgets': st.session_state.budgets.to_dict('records') if not st.session_state.budgets.empty else [],
+                    'savings_goals': st.session_state.savings_goals.to_dict('records') if not st.session_state.savings_goals.empty else []
+                }
+                
+                json_str = json.dumps(export_data, indent=2, default=str)
+                st.download_button(
+                    label="📥 Download Data as JSON",
+                    data=json_str,
+                    file_name=f"budget_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                    mime="application/json"
+                )
+                
+                # Also provide CSV export
+                if not st.session_state.expenses.empty:
+                    st.download_button(
+                        label="📊 Download Expenses CSV",
+                        data=st.session_state.expenses.to_csv(index=False).encode('utf-8'),
+                        file_name=f"expenses_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                        mime="text/csv"
+                    )
+            except Exception as e:
+                st.error(f"❌ Error exporting data: {str(e)}")
+        
+        # Privacy policy
+        st.subheader("📜 Privacy Policy")
+        with st.expander("Read Privacy Policy"):
+            st.write("""
+            **Data Collection:**
+            - We collect only the financial data you enter
+            - No personal identification information is collected
+            - All data is stored locally on your device
+            
+            **Data Usage:**
+            - Your data is used only for the functionality of this application
+            - We do not share your data with any third parties
+            - Data is not transmitted over the internet
+            
+            **Data Security:**
+            - All data is encrypted at rest
+            - You have full control over your data
+            - You can export or delete your data at any time
+            """)
+            
+    except Exception as e:
+        st.error(f"❌ Critical error in security section: {str(e)}")
+
+def bank_integration_placeholder():
+    """
+    Placeholder for bank integration feature
+    LLM Needed: NO - Just UI placeholder
+    Would need LLM for natural language banking queries
+    """
+    try:
+        st.subheader("🏦 Bank Integration (Coming Soon)")
+        
+        st.info("🚀 This feature will allow automatic syncing with your bank accounts!")
+        
+        st.write("📋 Planned Features:")
+        st.write("• Automatic transaction import")
+        st.write("• Real-time balance updates")
+        st.write("• Bank statement analysis")
+        st.write("• Automatic expense categorization")
+        
+        bank_name = st.selectbox("Select Bank", ["HDFC", "ICICI", "SBI", "Axis", "Kotak", "Other"])
+        if bank_name:
+            st.info(f"Bank integration for {bank_name} will be available soon!")
+            
+    except Exception as e:
+        st.error(f"❌ Error in bank integration section: {str(e)}")
+
+def main_dashboard():
+    """
+    Main dashboard overview
+    """
+    try:
+        st.subheader("🏠 Dashboard Overview")
+        
+        # Key metrics
+        col1, col2, col3, col4 = st.columns(4)
+        
+        total_expenses = st.session_state.expenses['amount'].sum() if not st.session_state.expenses.empty else 0
+        total_budget = st.session_state.budgets['budget_amount'].sum() if not st.session_state.budgets.empty else 0
+        total_savings = st.session_state.savings_goals['current_amount'].sum() if not st.session_state.savings_goals.empty else 0
+        expense_count = len(st.session_state.expenses)
+        
+        with col1:
+            st.metric("💰 Total Expenses", f"${total_expenses:.2f}")
+
+        with col2:
+            st.metric("📊 Total Budget", f"${total_budget:.2f}")
+
+        with col3:
+            st.metric("🏆 Total Savings", f"${total_savings:.2f}")
+
+        with col4:
+            st.metric("🧾 Expense Count", f"{expense_count}")
+        
+        # Quick actions
+        st.subheader("⚡ Quick Actions")
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            if st.button("🎤 Record Voice Expense"):
+                st.session_state.current_page = "🎤 Voice Expense"
+                st.rerun()
+        with col2:
+            if st.button("📸 Scan Receipt"):
+                st.session_state.current_page = "📸 OCR Receipts"
+                st.rerun()
+        with col3:
+            if st.button("📊 View Analytics"):
+                st.session_state.current_page = "📊 Visualizations"
+                st.rerun()
+        
+        # Recent activity
+        if not st.session_state.expenses.empty:
+            st.subheader("📅 Recent Expenses")
+            recent_expenses = st.session_state.expenses.tail(5)
+            st.dataframe(recent_expenses[['date', 'amount', 'category', 'description']])
+        else:
+            st.info("📝 No recent expenses. Start by adding your first expense!")
+        
+        # Budget status
+        if not st.session_state.budgets.empty:
+            st.subheader("📊 Budget Status")
+            for _, budget in st.session_state.budgets.iterrows():
+                category_spending = st.session_state.expenses[
+                    st.session_state.expenses['category'] == budget['category']
+                ]['amount'].sum()
+                
+                progress = (category_spending / budget['budget_amount']) * 100 if budget['budget_amount'] > 0 else 0
+                st.write(f"**{budget['category']}**")
+                st.progress(min(progress/100, 1.0))
+                st.write(f"${category_spending:.2f} / ${budget['budget_amount']:.2f} ({progress:.1f}%)")
+
+
+        
+        # Savings goals progress
+        if not st.session_state.savings_goals.empty:
+            st.subheader("🎯 Savings Goals Progress")
+            for _, goal in st.session_state.savings_goals.iterrows():
+                progress = (goal['current_amount'] / goal['target_amount']) * 100 if goal['target_amount'] > 0 else 0
+                st.write(f"**{goal['goal_name']}**")
+                st.progress(min(progress/100, 1.0))
+                st.write(f"${goal['current_amount']:.2f} / ${goal['target_amount']:.2f} ({progress:.1f}%)")
+
+
+        
+    except Exception as e:
+        st.error(f"❌ Error in dashboard: {str(e)}")
+
+def main():
+    """
+    Main application function with error handling
+    """
+    try:
+        # Initialize session state
+        if not initialize_session_state():
+            st.error("❌ Failed to initialize application. Please refresh the page.")
+            return
+        
+        # Set page config
+        st.set_page_config(
+            page_title="💰 Budget Tracker Pro",
+            page_icon="💰",
+            layout="wide",
+            initial_sidebar_state="expanded"
+        )
+        
+        # Custom CSS for better UI
+        st.markdown("""
+        <style>
+        .stApp {
+            background-color: #f0f2f6;
+        }
+        .stMetric {
+            background-color: white;
+            padding: 10px;
+            border-radius: 10px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .css-1d391kg {
+            background-color: #262730;
+        }
+        </style>
+        """, unsafe_allow_html=True)
+        
+        # App title and description
+        st.title("💰 Budget Tracker Pro")
+        st.markdown("*Your intelligent personal finance assistant*")
+        
+        # Sidebar navigation
+        st.sidebar.title("🧭 Navigation")
+        
+        # Initialize current page in session state
+        if 'current_page' not in st.session_state:
+            st.session_state.current_page = "🏠 Dashboard"
+        
+        menu = [
+            "🏠 Dashboard",
+            "🎤 Voice Expense", 
+            "📸 OCR Receipts", 
+            "💰 Budget", 
+            "🎯 Savings Goals", 
+            "🏷️ Categorization", 
+            "🔔 Alerts", 
+            "📊 Visualizations", 
+            "🧾 Receipts", 
+            "🔒 Security",
+            "🏦 Bank Integration"
+        ]
+        
+        # Page selection
+        choice = st.sidebar.selectbox("Choose a section", menu, 
+                                    index=menu.index(st.session_state.current_page))
+        st.session_state.current_page = choice
+        
+        # Display notifications in sidebar
+        if st.session_state.notifications:
+            st.sidebar.subheader("🔔 Notifications")
+            for notification in st.session_state.notifications[-3:]:  # Show last 3
+                if "🚨" in notification:
+                    st.sidebar.error(notification)
+                elif "⚠️" in notification:
+                    st.sidebar.warning(notification)
+        
+        # Route to appropriate function
+        if choice == "🏠 Dashboard":
+            main_dashboard()
+        elif choice == "🎤 Voice Expense":
+            voice_expense_recording()
+        elif choice == "📸 OCR Receipts":
+            ocr_receipt_processing()
+        elif choice == "💰 Budget":
+            create_budget()
+        elif choice == "🎯 Savings Goals":
+            set_savings_goals()
+        elif choice == "🏷️ Categorization":
+            spending_categorization()
+        elif choice == "🔔 Alerts":
+            alerts_and_notifications()
+        elif choice == "📊 Visualizations":
+            visualizations_and_summaries()
+        elif choice == "🧾 Receipts":
+            receipt_management()
+        elif choice == "🔒 Security":
+            data_security_and_privacy()
+        elif choice == "🏦 Bank Integration":
+            bank_integration_placeholder()
+        
+        # Footer
+        st.sidebar.markdown("---")
+        st.sidebar.info("💡 Tip: Use voice commands for quick expense logging!")
+        
+    except Exception as e:
+        st.error(f"❌ Critical application error: {str(e)}")
+        st.info("🔄 Please refresh the page or contact support if the issue persists.")
+
+if __name__ == "__main__":
+    main()