Upload 8 files

.env

@@ -0,0 +1 @@
+GOOGLE_API_KEY=AIzaSyCLyDgZNcE_v4wLMFF8SoimKga9bbLSun0

app.py

@@ -0,0 +1,214 @@
+import streamlit as st
+import pandas as pd
+from database import Database
+from voice_handler import VoiceHandler
+from gemini_processor import GeminiProcessor
+from memory_handler import MemoryHandler
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Initialize components
+try:
+    db = Database()
+    voice_handler = VoiceHandler()
+    gemini_processor = GeminiProcessor()
+    if 'memory_handler' not in st.session_state:
+        st.session_state.memory_handler = MemoryHandler()
+except Exception as e:
+    st.error(f"Error initializing components: {str(e)}")
+    st.stop()
+
+def validate_request(project_number, project_name, amount, reason):
+    if not project_number or not project_name or not amount or not reason:
+        missing_fields = []
+        if not project_number: missing_fields.append("project number")
+        if not project_name: missing_fields.append("project name")
+        if not amount: missing_fields.append("amount")
+        if not reason: missing_fields.append("reason")
+        return False, f"Please provide the following missing information: {', '.join(missing_fields)}"
+    return True, ""
+
+st.title("AI Agent Money Request System")
+st.markdown("---")
+
+# Language Selection
+if 'language' not in st.session_state:
+    st.session_state.language = "en-US"  # Default to English
+
+st.sidebar.title("Settings")
+language_option = st.sidebar.selectbox(
+    "Select Input Language",
+    options=["English", "Arabic", "Mixed (Arabic/English)"],
+    index=0,
+    key="language_select"
+)
+
+# Map selection to language codes
+language_mapping = {
+    "English": "en-US",
+    "Arabic": "ar-SA",
+    "Mixed (Arabic/English)": "mixed"
+}
+
+# Input Method Tabs
+tab1, tab2 = st.tabs(["Voice Input", "Text Input"])
+
+# Voice Input Tab
+with tab1:
+    col1, col2, col3 = st.columns([3, 1, 1])
+    with col1:
+        if language_option == "Arabic":
+            st.markdown("""
+            جرب أن تقول شيئاً مثل:
+            > "أحتاج إلى طلب 500 ريال للمشروع 223 المسمى جامعة أبها لشراء بعض الأدوات"
+            """)
+        else:
+            st.markdown("""
+            Try saying something like:
+            > "I need to request 500 riyals for project 223 named Abha University to buy some tools"
+            """)
+    with col2:
+        if st.button("🎤 Start Voice Input"):
+            with st.spinner("Listening... Please speak clearly"):
+                voice_text = voice_handler.listen_for_voice(language_mapping[language_option])
+                if not voice_text.startswith("Error") and not voice_text.startswith("Could not"):
+                    st.success("Voice captured!")
+                    st.write("You said:", voice_text)
+                    
+                    # Add to memory
+                    st.session_state.memory_handler.add_interaction(voice_text)
+                    
+                    with st.spinner("Processing voice input..."):
+                        context = st.session_state.memory_handler.get_context()
+                        details = gemini_processor.extract_request_details(voice_text, context)
+                        if details:
+                            st.session_state['voice_details'] = details
+                            if 'translated_text' in details:
+                                st.info(f"Translated text: {details['translated_text']}")
+                            if details.get('missing_fields'):
+                                missing = ", ".join(details['missing_fields'])
+                                st.warning(f"Please provide the following missing information: {missing}")
+                            else:
+                                st.success("Voice input processed! Please verify the details below.")
+                        else:
+                            st.error("Could not extract request details. Please try again or use manual input.")
+                else:
+                    st.error(voice_text)
+    with col3:
+        if st.button("🗑️ Clear Memory"):
+            st.session_state.memory_handler.clear_memory()
+            if 'voice_details' in st.session_state:
+                del st.session_state['voice_details']
+            st.success("Memory cleared!")
+
+# Text Input Tab
+with tab2:
+    if language_option == "Arabic":
+        st.markdown("""
+        أدخل طلبك في شكل نص. مثال:
+        > "أحتاج إلى طلب 500 ريال للمشروع 223 المسمى جامعة أبها لشراء بعض الأدوات"
+        """)
+    else:
+        st.markdown("""
+        Enter your request in text format. Example:
+        > "I need to request 500 riyals for project 223 named Abha University to buy some tools"
+        """)
+    
+    text_input = st.text_area("Enter your request:", height=100)
+    col1, col2 = st.columns([1, 4])
+    
+    with col1:
+        if st.button("Process Text"):
+            if text_input:
+                with st.spinner("Processing text input..."):
+                    context = st.session_state.memory_handler.get_context()
+                    details = gemini_processor.extract_request_details(text_input, context)
+                    if details:
+                        st.session_state['voice_details'] = details
+                        if 'translated_text' in details:
+                            st.info(f"Translated text: {details['translated_text']}")
+                        if details.get('missing_fields'):
+                            missing = ", ".join(details['missing_fields'])
+                            st.warning(f"Please provide the following missing information: {missing}")
+                        else:
+                            st.success("Text processed! Please verify the details below.")
+                    else:
+                        st.error("Could not extract request details. Please try again.")
+            else:
+                st.warning("Please enter some text first.")
+
+# Show conversation history
+if st.session_state.memory_handler.conversation_history:
+    with st.expander("Previous Inputs"):
+        for i, text in enumerate(st.session_state.memory_handler.conversation_history, 1):
+            st.text(f"{i}. {text}")
+
+# Input form
+st.markdown("---")
+st.subheader("Submit Money Request")
+with st.form("request_form"):
+    voice_details = st.session_state.get('voice_details', {})
+    
+    project_number = st.text_input("Project Number", value=voice_details.get('project_number', ''))
+    project_name = st.text_input("Project Name", value=voice_details.get('project_name', ''))
+    amount = st.number_input("Amount (in riyals)", 
+                           value=float(voice_details.get('amount', 0)),
+                           min_value=0.0, 
+                           step=100.0)
+    reason = st.text_input("Reason for Request", value=voice_details.get('reason', ''))
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        submitted = st.form_submit_button("Submit Request")
+    with col2:
+        confirmed = st.form_submit_button("Confirm & Save")
+
+if submitted:
+    is_valid, message = validate_request(project_number, project_name, amount, reason)
+    if is_valid:
+        st.session_state.show_confirmation = True
+        confirmation_text = f"""
+        Please review the following request and click 'Confirm & Save' to proceed:
+        
+        - Project Number: {project_number}
+        - Project Name: {project_name}
+        - Amount: {amount} riyals
+        - Reason: {reason}
+        """
+        st.info(confirmation_text)
+    else:
+        st.error(message)
+
+if confirmed:
+    is_valid, message = validate_request(project_number, project_name, amount, reason)
+    if is_valid:
+        try:
+            original_text = voice_details.get('original_text', '') if 'voice_details' in st.session_state else ''
+            db.add_request(project_number, project_name, amount, reason, original_text)
+            st.success("Request successfully added to the database!")
+            if 'voice_details' in st.session_state:
+                del st.session_state['voice_details']
+            st.session_state.show_confirmation = False
+            st.session_state.memory_handler.clear_memory()
+        except Exception as e:
+            st.error(f"Error saving request: {str(e)}")
+    else:
+        st.error(message)
+
+# Display existing requests
+st.markdown("---")
+st.subheader("Existing Requests")
+try:
+    requests = db.get_all_requests()
+    if requests:
+        df = pd.DataFrame(requests)
+        # Reorder columns to show original text
+        columns = ['timestamp', 'project_number', 'project_name', 'amount', 'reason', 'original_text']
+        df = df[columns]
+        st.dataframe(df, use_container_width=True)
+    else:
+        st.info("No requests submitted yet.")
+except Exception as e:
+    st.error(f"Error loading requests: {str(e)}")

database.py

@@ -0,0 +1,103 @@
+import sqlite3
+from datetime import datetime
+import os
+import time
+
+class Database:
+    def __init__(self, db_name="requests.db"):
+        self.db_name = db_name
+        self.max_retries = 3
+        self.retry_delay = 1  
+        self.initialize_database()
+    
+    def initialize_database(self):
+        for attempt in range(self.max_retries):
+            try:
+                
+                self.conn = sqlite3.connect(self.db_name)
+                
+                self.conn.execute('PRAGMA encoding="UTF-8"')
+                
+                
+                cursor = self.conn.cursor()
+                cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='requests'")
+                if not cursor.fetchone():
+                    self.create_table()
+                else:
+                    # Verify columns
+                    cursor.execute('PRAGMA table_info(requests)')
+                    columns = [col[1] for col in cursor.fetchall()]
+                    required_columns = ['id', 'timestamp', 'project_number', 'project_name', 'amount', 'reason', 'original_text']
+                    
+                    if not all(col in columns for col in required_columns):
+                        # Backup existing data
+                        cursor.execute('ALTER TABLE requests RENAME TO requests_old')
+                        self.create_table()
+                        # Copy data from old table
+                        cursor.execute('''
+                            INSERT INTO requests (timestamp, project_number, project_name, amount, reason)
+                            SELECT timestamp, project_number, project_name, amount, reason
+                            FROM requests_old
+                        ''')
+                        cursor.execute('DROP TABLE requests_old')
+                        self.conn.commit()
+                
+                return  # Success
+            except sqlite3.OperationalError as e:
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+                    continue
+                raise Exception(f"Could not initialize database after {self.max_retries} attempts: {str(e)}")
+            except Exception as e:
+                raise Exception(f"Database initialization error: {str(e)}")
+    
+    def create_table(self):
+        cursor = self.conn.cursor()
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS requests (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp DATETIME,
+                project_number TEXT,
+                project_name TEXT,
+                amount REAL,
+                reason TEXT,
+                original_text TEXT
+            )
+        ''')
+        self.conn.commit()
+    
+    def add_request(self, project_number, project_name, amount, reason, original_text=""):
+        for attempt in range(self.max_retries):
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                    INSERT INTO requests (timestamp, project_number, project_name, amount, reason, original_text)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                ''', (datetime.now(), project_number, project_name, amount, reason, original_text))
+                self.conn.commit()
+                return  # Success
+            except sqlite3.OperationalError as e:
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+                    continue
+                raise Exception(f"Could not add request after {self.max_retries} attempts: {str(e)}")
+    
+    def get_all_requests(self):
+        for attempt in range(self.max_retries):
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('SELECT * FROM requests ORDER BY timestamp DESC')
+                columns = [description[0] for description in cursor.description]
+                results = cursor.fetchall()
+                return [dict(zip(columns, row)) for row in results]
+            except sqlite3.OperationalError as e:
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+                    continue
+                raise Exception(f"Could not fetch requests after {self.max_retries} attempts: {str(e)}")
+    
+    def __del__(self):
+        try:
+            self.conn.close()
+        except:
+            pass

gemini_processor.py

@@ -0,0 +1,86 @@
+import google.generativeai as genai
+import os
+from dotenv import load_dotenv
+import json
+import re
+
+load_dotenv()
+
+class GeminiProcessor:
+    def __init__(self):
+        api_key = os.getenv('GOOGLE_API_KEY')
+        if not api_key:
+            raise ValueError("GOOGLE_API_KEY not found in environment variables")
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel('gemini-pro')
+    
+    def is_arabic(self, text):
+        arabic_pattern = re.compile('[\u0600-\u06FF]')
+        return bool(arabic_pattern.search(text))
+    
+    def translate_arabic_to_english(self, text):
+        prompt = f"""
+        Translate the following Arabic text to English. If the text is mixed (Arabic and English),
+        translate only the Arabic parts and keep the English parts as is.
+        Keep numbers in their original format.
+        
+        Text to translate: {text}
+        """
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text.strip()
+        except Exception as e:
+            print(f"Translation error: {e}")
+            return text
+    
+    def extract_request_details(self, text, context=""):
+        full_text = f"{context} {text}".strip()
+        is_arabic_input = self.is_arabic(full_text)
+        
+        # Translate if Arabic text is detected
+        if is_arabic_input:
+            translated_text = self.translate_arabic_to_english(full_text)
+            processing_text = translated_text
+        else:
+            processing_text = full_text
+        
+        prompt = f"""
+        Extract the following information from this text and previous context.
+        The input has been translated from Arabic if it contained Arabic text.
+        
+        If any information is missing, leave it empty.
+        Format the response exactly as a JSON object with these keys:
+        {{
+            "project_number": "extracted number or empty string",
+            "project_name": "extracted name or empty string",
+            "amount": extracted number or 0,
+            "reason": "extracted reason or empty string",
+            "missing_fields": ["list of missing required fields"],
+            "original_text": "the original input text"
+        }}
+
+        Text to analyze: {processing_text}
+        """
+        
+        try:
+            response = self.model.generate_content(prompt)
+            result = json.loads(response.text)
+            
+            required_keys = ['project_number', 'project_name', 'amount', 'reason', 'missing_fields']
+            if not all(key in result for key in required_keys):
+                raise ValueError("Missing required keys in response")
+            
+            result['amount'] = float(result.get('amount', 0))
+            result['original_text'] = full_text  # Keep the original Arabic text
+            
+            # Add translation if it was performed
+            if is_arabic_input:
+                result['translated_text'] = processing_text
+            
+            return result
+        except json.JSONDecodeError as e:
+            print(f"JSON parsing error: {e}")
+            return None
+        except Exception as e:
+            print(f"Error processing request: {e}")
+            return None

memory_handler.py

@@ -0,0 +1,15 @@
+class MemoryHandler:
+    def __init__(self):
+        self.conversation_history = []
+        self.max_history = 5  # Keep last 5 interactions
+    
+    def add_interaction(self, text):
+        self.conversation_history.append(text)
+        if len(self.conversation_history) > self.max_history:
+            self.conversation_history.pop(0)
+    
+    def get_context(self):
+        return " ".join(self.conversation_history)
+    
+    def clear_memory(self):
+        self.conversation_history = []

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+pandas
+SpeechRecognition
+google-generativeai
+pyaudio
+python-dotenv

voice_handler.py

@@ -0,0 +1,50 @@
+import speech_recognition as sr
+
+class VoiceHandler:
+    def __init__(self):
+        self.recognizer = sr.Recognizer()
+        # Adjust recognition settings for better accuracy
+        self.recognizer.energy_threshold = 4000
+        self.recognizer.dynamic_energy_threshold = True
+        self.recognizer.pause_threshold = 0.8
+    
+    def listen_for_voice(self, language="mixed"):
+        """
+        Listen for voice input in specified language.
+        language can be: 
+        - "ar-SA" for Arabic
+        - "en-US" for English
+        - "mixed" for both Arabic and English
+        """
+        try:
+            with sr.Microphone() as source:
+                print("Adjusting for ambient noise...")
+                self.recognizer.adjust_for_ambient_noise(source, duration=1)
+                print("Listening...")
+                audio = self.recognizer.listen(source, timeout=5, phrase_time_limit=10)
+                print("Processing speech...")
+                
+                # Try Arabic first if mixed or Arabic is specified
+                if language in ["ar-SA", "mixed"]:
+                    try:
+                        text = self.recognizer.recognize_google(audio, language="ar-SA")
+                        return text
+                    except sr.UnknownValueError:
+                        if language == "mixed":
+                            # If Arabic fails and mixed is specified, try English
+                            text = self.recognizer.recognize_google(audio, language="en-US")
+                            return text
+                        raise
+                else:
+                    # English only
+                    text = self.recognizer.recognize_google(audio, language="en-US")
+                    return text
+                    
+        except sr.RequestError as e:
+            return f"Could not request results from speech service: {str(e)}"
+        except sr.UnknownValueError:
+            return "Could not understand audio. Please speak clearly and try again."
+        except sr.WaitTimeoutError:
+            return "Listening timed out. Please try again."
+        except Exception as e:
+            return f"Error: {str(e)}"