Update app.py

app.py

@@ -1,134 +1,316 @@
-# utils.py
-from transformers import pipeline
-from gtts import gTTS
-import speech_recognition as sr
-import io
-import requests
-import json
 import os
-from datetime import datetime
-import streamlit as st
+# Fix Hugging Face Spaces permissions - Comprehensive solution
+os.environ['STREAMLIT_GLOBAL_METRICS'] = '0'
+os.environ['STREAMLIT_SERVER_ENABLE_STATIC_SERVE'] = '1'
+os.environ['STREAMLIT_GLOBAL_DEVELOPMENT_MODE'] = '0'
+os.environ['STREAMLIT_GLOBAL_CONFIG_DIR'] = '/tmp'  # Redirect config directory
+os.environ['STREAMLIT_GLOBAL_DATA_DIR'] = '/tmp'    # Redirect data directory
+os.environ['HOME'] = '/tmp'                         # Redirect home directory
 
-# Initialize AI models
-@st.cache_resource
-def load_ai_models():
-    return {
-        "text_gen": pipeline("text-generation", model="gpt2"),
-        "sentiment": pipeline("sentiment-analysis"),
-        "summarization": pipeline("summarization", model="facebook/bart-large-cnn")
-    }
+# Prevent Streamlit from writing to protected directories
+import streamlit.runtime.metrics_util
+def patched_get_machine_id_v4():
+    return "anonymous-id"
+streamlit.runtime.metrics_util._get_machine_id_v4 = patched_get_machine_id_v4
 
-# Text-to-speech
-def text_to_speech(text, lang="en"):
-    try:
-        tts = gTTS(text=text, lang=lang)
-        audio_bytes = io.BytesIO()
-        tts.write_to_fp(audio_bytes)
-        audio_bytes.seek(0)
-        return audio_bytes
-    except Exception as e:
-        print(f"Text-to-speech error: {e}")
-        return None
+import streamlit
+import json
+import time
+import base64
+import threading
+from datetime import datetime, timedelta
+from utils import text_to_speech, speech_to_text, generate_ai_response, get_weather_forecast
+from streamlit_mic_recorder import mic_recorder
 
-# Speech-to-text
-def speech_to_text(audio_path):
-    try:
-        r = sr.Recognizer()
-        with sr.AudioFile(audio_path) as source:
-            audio = r.record(source)
-        return r.recognize_google(audio)
-    except Exception as e:
-        print(f"Speech-to-text error: {e}")
-        return "Could not understand audio"
+# Create data directories
+DATA_DIR = "data"
+os.makedirs(DATA_DIR, exist_ok=True)
+VOICE_DIR = os.path.join(DATA_DIR, "voice_notes")
+os.makedirs(VOICE_DIR, exist_ok=True)
+DATA_FILE = os.path.join(DATA_DIR, "reminders.json")
+
+# Initialize session state
+def init_session():
+    if "reminders" not in st.session_state:
+        st.session_state.reminders = load_reminders()
+    if "ai_enabled" not in st.session_state:
+        st.session_state.ai_enabled = True
+    if "weather_enabled" not in st.session_state:
+        st.session_state.weather_enabled = True
+    if "voice_notes" not in st.session_state:
+        st.session_state.voice_notes = {}
+    if "notifications" not in st.session_state:
+        st.session_state.notifications = []
 
-# Weather API (using Open-Meteo)
-def get_weather_forecast(date):
+# Data management
+def load_reminders():
     try:
-        # Convert date to string in YYYY-MM-DD format
-        date_str = date.strftime("%Y-%m-%d")
-        
-        # Get latitude and longitude for a central location (New York as default)
-        latitude = 40.7128
-        longitude = -74.0060
+        if os.path.exists(DATA_FILE):
+            with open(DATA_FILE, "r") as f:
+                return json.load(f)
+        return []
+    except json.JSONDecodeError:
+        return []
+
+def save_reminders():
+    with open(DATA_FILE, "w") as f:
+        json.dump(st.session_state.reminders, f)
+
+# Voice functions
+def save_voice_note(audio_bytes, reminder_id):
+    filename = f"{VOICE_DIR}/{reminder_id}_{int(time.time())}.wav"
+    with open(filename, "wb") as f:
+        f.write(audio_bytes)
+    return filename
+
+def play_voice_note(path):
+    if os.path.exists(path):
+        with open(path, "rb") as f:
+            audio_bytes = f.read()
+        st.audio(audio_bytes, format="audio/wav")
+    else:
+        st.warning("Voice note file not found")
+
+# Notification system
+def check_reminders():
+    while True:
+        now = datetime.now()
+        for reminder in st.session_state.reminders:
+            if not reminder.get('completed') and not reminder.get('notification_sent'):
+                try:
+                    due_time = datetime.strptime(reminder['due_time'], "%H:%M:%S.%f").time() if '.' in reminder['due_time'] else datetime.strptime(reminder['due_time'], "%H:%M:%S").time()
+                    due_date = datetime.strptime(reminder['due_date'], "%Y-%m-%d").date()
+                    
+                    if due_date == now.date() and due_time.hour == now.hour and due_time.minute == now.minute:
+                        # Create notification
+                        notification = {
+                            "id": int(time.time() * 1000),
+                            "reminder_id": reminder['id'],
+                            "title": reminder['title'],
+                            "time": str(now),
+                            "dismissed": False
+                        }
+                        
+                        st.session_state.notifications.append(notification)
+                        reminder['notification_sent'] = True
+                        save_reminders()
+                        
+                        # Play notification
+                        if reminder.get('voice_note') and os.path.exists(reminder['voice_note']):
+                            threading.Thread(target=play_voice_note, args=(reminder['voice_note'],)).start()
+                        else:
+                            threading.Thread(
+                                target=lambda: st.toast(f"🔔 Reminder: {reminder['title']}"),
+                                daemon=True
+                            ).start()
+                except Exception as e:
+                    print(f"Notification error: {e}")
+        time.sleep(60)  # Check every minute
+
+# Start notification thread
+if "notification_thread" not in st.session_state:
+    st.session_state.notification_thread = threading.Thread(target=check_reminders, daemon=True)
+    st.session_state.notification_thread.start()
+
+# Main app
+def main():
+    st.set_page_config(
+        page_title="AI-Powered Reminder System", 
+        layout="wide",
+        page_icon="⏰"
+    )
+    init_session()
+    
+    # Sidebar
+    with st.sidebar:
+        st.header("⚙️ System Settings")
+        st.session_state.ai_enabled = st.checkbox("Enable AI Insights", value=True)
+        st.session_state.weather_enabled = st.checkbox("Show Weather Forecast", value=True)
         
-        # Make API request
-        url = f"https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}&daily=weathercode,temperature_2m_max,temperature_2m_min&timezone=auto&start_date={date_str}&end_date={date_str}"
-        response = requests.get(url)
-        data = response.json()
+        st.divider()
         
-        # Extract weather data
-        if "daily" in data:
-            temp_max = data["daily"]["temperature_2m_max"][0]
-            temp_min = data["daily"]["temperature_2m_min"][0]
-            weather_code = data["daily"]["weathercode"][0]
+        st.header("📝 Add New Reminder")
+        with st.form("new_reminder", clear_on_submit=True):
+            title = st.text_input("Title*", placeholder="What to remember?")
+            description = st.text_area("Description", placeholder="Details...")
             
-            # Convert weather code to description
-            weather_descriptions = {
-                0: "Clear sky",
-                1: "Mainly clear",
-                2: "Partly cloudy",
-                3: "Overcast",
-                45: "Fog",
-                48: "Depositing rime fog",
-                51: "Light drizzle",
-                53: "Moderate drizzle",
-                55: "Dense drizzle",
-                56: "Light freezing drizzle",
-                57: "Dense freezing drizzle",
-                61: "Slight rain",
-                63: "Moderate rain",
-                65: "Heavy rain",
-                66: "Light freezing rain",
-                67: "Heavy freezing rain",
-                71: "Slight snow",
-                73: "Moderate snow",
-                75: "Heavy snow",
-                77: "Snow grains",
-                80: "Slight rain showers",
-                81: "Moderate rain showers",
-                82: "Violent rain showers",
-                85: "Slight snow showers",
-                86: "Heavy snow showers",
-                95: "Thunderstorm",
-                96: "Thunderstorm with slight hail",
-                99: "Thunderstorm with heavy hail"
-            }
+            col1, col2 = st.columns(2)
+            due_date = col1.date_input("Date*", min_value=datetime.today())
+            due_time = col2.time_input("Time*", value=datetime.now().time())
             
-            weather_desc = weather_descriptions.get(weather_code, "Unknown")
-            return f"{weather_desc}, High: {temp_max}°C, Low: {temp_min}°C"
-        
-        return "Weather data unavailable"
-    except Exception as e:
-        print(f"Weather API error: {e}")
-        return "Weather service unavailable"
-
-# AI analysis
-def generate_ai_response(prompt):
-    try:
-        models = load_ai_models()
-        
-        # Generate insights
-        insights = models["text_gen"](
-            f"Analyze this reminder and provide helpful suggestions: {prompt}",
-            max_length=200,
-            num_return_sequences=1
-        )[0]['generated_text']
-        
-        # Sentiment analysis
-        sentiment = models["sentiment"](prompt[:512])[0]
+            priority = st.select_slider("Priority", ["Low", "Medium", "High"], value="Medium")
+            voice_note = st.checkbox("Add Voice Reminder")
+            
+            # Voice recorder
+            audio_bytes = None
+            if voice_note:
+                audio = mic_recorder(
+                    start_prompt="⏺️ Start Recording",
+                    stop_prompt="⏹️ Stop Recording",
+                    key=f"recorder_{int(time.time())}"
+                )
+                if audio and 'bytes' in audio:
+                    audio_bytes = audio['bytes']
+                    if audio_bytes:
+                        st.audio(audio_bytes, format="audio/wav")
+            
+            submitted = st.form_submit_button("Create Reminder")
+            if submitted and title:
+                new_reminder = {
+                    "id": int(time.time() * 1000),
+                    "title": title,
+                    "description": description,
+                    "due_date": str(due_date),
+                    "due_time": str(due_time),
+                    "priority": priority,
+                    "created_at": str(datetime.now()),
+                    "completed": False,
+                    "voice_note": ""
+                }
+                
+                if voice_note and audio_bytes:
+                    voice_path = save_voice_note(audio_bytes, new_reminder["id"])
+                    new_reminder["voice_note"] = voice_path
+                
+                if st.session_state.ai_enabled:
+                    with st.spinner("Generating AI insights..."):
+                        new_reminder["ai_insights"] = generate_ai_response(
+                            f"Reminder: {title}. Description: {description}. "
+                            f"Due: {due_date} at {due_time}. Priority: {priority}"
+                        )
+                
+                st.session_state.reminders.append(new_reminder)
+                save_reminders()
+                st.success("Reminder created successfully!")
+                st.experimental_rerun()
+    
+    # Main interface
+    st.title("⏰ AI-Powered Reminder System")
+    
+    # Dashboard
+    col1, col2, col3 = st.columns(3)
+    pending = sum(1 for r in st.session_state.reminders if not r.get('completed', False))
+    high_priority = sum(1 for r in st.session_state.reminders if not r.get('completed', False) and r.get('priority') == "High")
+    
+    with col1:
+        st.metric("Total Reminders", len(st.session_state.reminders))
+    with col2:
+        st.metric("Pending Tasks", pending)
+    with col3:
+        st.metric("High Priority", high_priority)
+    
+    # Notifications
+    if st.session_state.notifications:
+        with st.expander("🔔 Active Notifications", expanded=True):
+            for notification in st.session_state.notifications[:]:
+                if not notification.get('dismissed', False):
+                    st.warning(f"{notification['title']} - {notification['time'][11:16]}")
+                    if st.button("Dismiss", key=f"dismiss_{notification['id']}"):
+                        notification['dismissed'] = True
+                        # Update the original reminder
+                        for reminder in st.session_state.reminders:
+                            if reminder['id'] == notification['reminder_id']:
+                                reminder['notification_sent'] = False
+                        st.experimental_rerun()
+    
+    # Calendar view
+    with st.expander("📅 Calendar View", expanded=True):
+        selected_date = st.date_input("View reminders for", value=datetime.today(), key="calendar_date")
+        date_reminders = [r for r in st.session_state.reminders 
+                         if datetime.strptime(r["due_date"], "%Y-%m-%d").date() == selected_date]
         
-        # Summarization
-        summary = models["summarization"](
-            insights,
-            max_length=100,
-            min_length=30,
-            do_sample=False
-        )[0]['summary_text']
+        if st.session_state.weather_enabled:
+            try:
+                weather = get_weather_forecast(selected_date)
+                st.info(f"🌤️ Weather Forecast: {weather}")
+            except:
+                st.warning("Weather service unavailable")
         
-        # Format final response
-        return (f"**AI Summary**: {summary}\n\n"
-                f"**Sentiment**: {sentiment['label']} (confidence: {sentiment['score']:.0%})\n\n"
-                f"**Detailed Analysis**:\n{insights}")
-    except Exception as e:
-        print(f"AI analysis error: {e}")
-        return "AI insights unavailable at this time"
+        if not date_reminders:
+            st.info("No reminders for selected date")
+        else:
+            for r in date_reminders:
+                with st.container(border=True):
+                    cols = st.columns([0.7, 3, 1])
+                    cols[0].checkbox(
+                        f"Done {r['id']}", 
+                        value=r.get("completed", False), 
+                        key=f"completed_{r['id']}",
+                        on_change=lambda id=r['id']: update_completion(id)
+                    )
+                    
+                    with cols[1]:
+                        st.subheader(r["title"])
+                        st.caption(f"⏰ {r['due_time'][:5]} | {r['priority']} priority")
+                        
+                        if r.get("description"):
+                            st.write(r["description"])
+                        
+                        if r.get("voice_note"):
+                            st.write("Voice Reminder:")
+                            play_voice_note(r["voice_note"])
+                        
+                        if st.session_state.ai_enabled and r.get("ai_insights"):
+                            with st.expander("🤖 AI Insights"):
+                                st.write(r["ai_insights"])
+                    
+                    with cols[2]:
+                        if st.button("🗑️", key=f"delete_{r['id']}"):
+                            delete_reminder(r["id"])
+    
+    # Upcoming reminders
+    st.subheader("🚨 Upcoming Alerts (Next 7 Days)")
+    today = datetime.today().date()
+    next_week = today + timedelta(days=7)
+    
+    upcoming = sorted(
+        [r for r in st.session_state.reminders 
+         if not r.get('completed', False) and 
+         today <= datetime.strptime(r["due_date"], "%Y-%m-%d").date() <= next_week],
+        key=lambda x: (x["due_date"], x["due_time"])
+    )
+    
+    if not upcoming:
+        st.info("No upcoming reminders in the next week")
+    else:
+        for r in upcoming:
+            due_date = datetime.strptime(r["due_date"], "%Y-%m-%d").date()
+            days_left = (due_date - today).days
+            days_text = "today" if days_left == 0 else f"in {days_left} days"
+            
+            with st.container(border=True):
+                cols = st.columns([3, 1])
+                cols[0].subheader(r["title"])
+                cols[0].caption(f"📅 {r['due_date']} at {r['due_time'][:5]} ({days_text}) | {r['priority']} priority")
+                
+                if r.get("description"):
+                    cols[0].write(r["description"])
+                
+                with cols[1]:
+                    if st.button("Complete", key=f"complete_{r['id']}"):
+                        complete_reminder(r['id'])
+                        st.experimental_rerun()
+
+# Helper functions
+def update_completion(reminder_id):
+    for r in st.session_state.reminders:
+        if r["id"] == reminder_id:
+            r["completed"] = st.session_state[f"completed_{reminder_id}"]
+            if r['completed']:
+                r['completion_time'] = str(datetime.now())
+    save_reminders()
+
+def complete_reminder(reminder_id):
+    for r in st.session_state.reminders:
+        if r["id"] == reminder_id:
+            r["completed"] = True
+            r['completion_time'] = str(datetime.now())
+    save_reminders()
+
+def delete_reminder(reminder_id):
+    st.session_state.reminders = [r for r in st.session_state.reminders if r["id"] != reminder_id]
+    save_reminders()
+    st.experimental_rerun()
+
+if __name__ == "__main__":
+    main()