Update app.py

app.py

@@ -1,545 +1,467 @@
 import gradio as gr
+import requests
 import json
 import datetime
-from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, tool
-from typing import Dict, List, Any
 import re
+from bs4 import BeautifulSoup
+from typing import Optional, Dict, Any
+import geocoder
+import pytz
+from urllib.parse import quote, urljoin
 
-# Import your existing tools (assuming they're in the same file or properly imported)
-# For this example, I'll include the key functions inline
-
-@tool
-def speech_emotion_analyzer(text: str, context: str = "therapy") -> str:
+class ShabbatCandleLightingAgent:
     """
-    Analyzes patient's emotional state from speech text.
-    
-    Args:
-        text: Patient's speech text
-        context: Context (therapy, assessment, crisis)
-    
-    Returns:
-        Analysis of emotional state and recommendations
+    AI Agent for finding Shabbat candle lighting times worldwide using Chabad.org
     """
-    if not text or len(text.strip()) < 10:
-        return "Error: Text must be at least 10 characters long for analysis."
-    
-    # Emotion indicators for analysis
-    emotion_indicators = {
-        "depression": {
-            "keywords": ["sad", "hopeless", "tired", "meaningless", "empty", "lonely", 
-                        "depressed", "despair", "miserable", "worthless", "numb"],
-            "patterns": [r"can't.*sleep", r"no.*energy", r"everything.*bad", r"don't.*want", 
-                        r"life.*no.*meaning", r"better.*dead"]
-        },
-        "anxiety": {
-            "keywords": ["anxious", "worried", "nervous", "scared", "panic", "tense",
-                        "anxiety", "worry", "fear", "stress", "phobia"],
-            "patterns": [r"what.*if", r"afraid.*that", r"can't.*cope", r"heart.*racing",
-                        r"hands.*shaking", r"can't.*breathe", r"panic.*attack"]
-        },
-        "anger": {
-            "keywords": ["angry", "furious", "irritated", "annoyed", "hate", "mad",
-                        "rage", "aggression", "hatred", "frustration"],
-            "patterns": [r"fed up", r"sick of", r"can't.*stand", r"want.*hit",
-                        r"everything.*irritates", r"pissed off"]
-        },
-        "stress": {
-            "keywords": ["stress", "pressure", "overwhelmed", "exhausted", "burned out",
-                        "burnout", "fatigue","job interview", "drained"],
-            "patterns": [r"too.*much.*work", r"can't.*keep up", r"headache", r"no.*time",
-                        r"swamped", r"working.*nonstop",r"job.*interview"]
-        },
-        "trauma": {
-            "keywords": ["trauma", "flashbacks", "nightmares", "memories", "avoiding",
-                        "ptsd", "triggered", "shock"],
-            "patterns": [r"keep.*remembering", r"bad.*dreams", r"can't.*forget",
-                        r"avoid.*places", r"triggers"]
-        }
-    }
-    
-    # Analyze text
-    text_lower = text.lower()
-    detected_emotions = {}
     
-    for emotion, indicators in emotion_indicators.items():
-        score = 0
-        matches = []
+    def __init__(self):
+        self.base_url = "https://www.chabad.org"
+        self.candle_lighting_url = "https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm"
+        self.search_url = "https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm"
         
-        # Check keywords
-        for keyword in indicators["keywords"]:
-            if keyword in text_lower:
-                score += 1
-                matches.append(keyword)
-        
-        # Check patterns
-        for pattern in indicators["patterns"]:
-            if re.search(pattern, text_lower):
-                score += 2
-                matches.append(f"pattern: {pattern}")
-        
-        if score > 0:
-            detected_emotions[emotion] = {"score": score, "matches": matches}
-    
-    # Check for crisis indicators
-    crisis_indicators = ["suicide", "kill myself", "end it all", "not worth living", "better off dead"]
-    crisis_risk = any(indicator in text_lower for indicator in crisis_indicators)
-    
-    # Check positive indicators
-    positive_indicators = ["happy", "joy", "good", "great", "wonderful", "excited", "grateful", "love"]
-    positive_count = sum(1 for indicator in positive_indicators if indicator in text_lower)
-    
-    # Create report
-    report = "## 🧠 Emotional State Analysis\n\n"
-    
-    if detected_emotions:
-        report += "### 📊 Detected Emotional States:\n"
-        for emotion, data in sorted(detected_emotions.items(), key=lambda x: x[1]["score"], reverse=True):
-            emotion_names = {
-                "depression": "😔 Depression signs",
-                "anxiety": "😰 Anxiety", 
-                "anger": "😠 Anger/Irritation",
-                "stress": "😵 Stress",
-                "trauma": "💔 Trauma-related"
+    def get_user_location(self) -> Optional[Dict[str, Any]]:
+        """
+        Automatically detect user's location using IP geolocation
+        """
+        try:
+            # Get location from IP
+            g = geocoder.ip('me')
+            if g.ok:
+                return {
+                    'city': g.city,
+                    'country': g.country,
+                    'lat': g.latlng[0] if g.latlng else None,
+                    'lng': g.latlng[1] if g.latlng else None,
+                    'timezone': g.timezone if hasattr(g, 'timezone') else None
+                }
+        except Exception as e:
+            print(f"Location detection error: {e}")
+        return None
+    
+    def search_city_on_chabad(self, city_name: str) -> Optional[str]:
+        """
+        Search for a city on Chabad.org and get the specific URL for candle lighting times
+        """
+        try:
+            # Format city name for search
+            search_query = quote(city_name)
+            
+            # Try different search approaches
+            search_urls = [
+                f"https://www.chabad.org/calendar/candlelighting_cdo/city/{search_query}/jewish/Candle-Lighting.htm",
+                f"https://www.chabad.org/calendar/candlelighting_cdo/jewish/Candle-Lighting.htm?city={search_query}",
+                f"https://www.chabad.org/calendar/candlelighting.asp?city={search_query}"
+            ]
+            
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
             }
-            intensity = "High" if data['score'] >= 4 else "Medium" if data['score'] >= 2 else "Low"
-            report += f"- {emotion_names[emotion]} (intensity: {intensity})\n"
-            report += f"  Found indicators: {', '.join(data['matches'][:3])}\n\n"
-    else:
-        report += "✅ No clear signs of emotional distress detected.\n\n"
-    
-    # Positive aspects
-    if positive_count > 0:
-        report += f"😊 Positive indicators: Found {positive_count} positive marker(s)\n\n"
-    
-    # Crisis assessment
-    if crisis_risk:
-        report += "🚨 CRITICAL: Suicide risk indicators detected!\n"
-        report += "📞 Immediate consultation and safety assessment recommended.\n"
-        report += "Emergency services: 101, Crisis hotline: \n\n"
-    
-    # Treatment recommendations
-    report += "### 🎯 Treatment Recommendations:\n"
-    
-    if "depression" in detected_emotions:
-        report += "- 🧘 CBT (Cognitive Behavioral Therapy) for negative thought patterns\n"
-        report += "- 💊 Consider psychiatric consultation for medication support\n"
-        report += "- 🏃 Behavioral activation (increase pleasant activities)\n"
-    
-    if "anxiety" in detected_emotions:
-        report += "- 🫁 Relaxation techniques: breathing exercises, progressive muscle relaxation\n"
-        report += "- 🎭 Exposure therapy for phobic avoidance\n"
-        report += "- 🧠 Mindfulness therapy for anxious thoughts\n"
-    
-    if "anger" in detected_emotions:
-        report += "- 🎯 Anger management training and self-regulation techniques\n"
-        report += "- 🔍 Trigger identification and behavior patterns\n"
-        report += "- 🤝 Communication skills training\n"
-    
-    if "stress" in detected_emotions:
-        report += "- ⏰ Stress management and time management techniques\n"
-        report += "- ⚖️ Work-life balance assessment and adjustment\n"
-        report += "- 🛡️ Coping strategies for stressful situations\n"
-    
-    if "trauma" in detected_emotions:
-        report += "- 👁️ EMDR therapy for traumatic memories\n"
-        report += "- 🏠 Trauma-informed approach in therapy\n"
-        report += "- 🧘 Somatic techniques for body-based trauma symptoms\n"
-    
-    if not detected_emotions or positive_count > 2:
-        report += "- 💪 Supportive therapy to maintain resources\n"
-        report += "- 🎯 Personal growth and life goals development\n"
-    
-    report += f"\n📅 Analysis date: {datetime.datetime.now().strftime('%m/%d/%Y %H:%M')}"
-    report += f"\n🌍 Context: {context}"
-    
-    return report
-
-@tool
-def create_therapy_worksheet(therapy_type: str, client_age: int, issue: str) -> str:
-    """
-    Creates a therapeutic worksheet/exercise for client.
-    
-    Args:
-        therapy_type: Type of therapy (cbt, dbt, art, mindfulness)
-        client_age: Client's age
-        issue: Main problem
-    
-    Returns:
-        Structured therapeutic worksheet
-    """
-    if client_age < 5 or client_age > 100:
-        return "Error: Age must be between 5 and 100."
-    
-    therapy_type = therapy_type.lower()
-    valid_types = ["cbt", "dbt", "art", "mindfulness"]
-    
-    if therapy_type not in valid_types:
-        return f"Error: Therapy type must be one of: {', '.join(valid_types)}"
-    
-    # Determine level by age
-    if client_age < 12:
-        level = "child"
-    elif client_age < 18:
-        level = "teen" 
-    else:
-        level = "adult"
+            
+            for url in search_urls:
+                try:
+                    response = requests.get(url, headers=headers, timeout=10)
+                    if response.status_code == 200 and 'candle lighting' in response.text.lower():
+                        return url
+                except:
+                    continue
+                    
+            # Try the main search page with POST request
+            try:
+                search_payload = {
+                    'city': city_name,
+                    'submit': 'Search'
+                }
+                response = requests.post(self.candle_lighting_url, data=search_payload, headers=headers, timeout=10)
+                if response.status_code == 200:
+                    return response.url
+            except:
+                pass
+                
+        except Exception as e:
+            print(f"City search error: {e}")
+        
+        return None
     
-    worksheets = {
-        "cbt": {
-            "child": {
-                "title": "🌈 My Thoughts and Feelings",
-                "exercises": [
-                    "🌤️ Mood Diary: Draw or mark your mood with an emoji each day",
-                    "🤔 Thought Catcher: Write down thoughts when sad or scared",
-                    "🎯 Helper Thoughts: Find 3 good thoughts for each bad thought",
-                    "⭐ My Successes: Write one good thing you did each day"
-                ]
-            },
-            "teen": {
-                "title": "🧠 Cognitive Restructuring",
-                "exercises": [
-                    "📊 ABC Model: Situation (A) → Thought (B) → Feeling/Behavior (C)",
-                    "🔍 Thought Detective: Find evidence FOR and AGAINST your beliefs",
-                    "⚖️ Alternative Thoughts: Find 2-3 realistic alternatives for negative thoughts",
-                    "📝 Thought Diary: Daily record of automatic thoughts"
-                ]
-            },
-            "adult": {
-                "title": "🔄 Cognitive Behavioral Therapy",
-                "exercises": [
-                    "🔄 Thought-Feeling-Behavior Cycle: Analyze connections in situations",
-                    "⚡ Cognitive Distortions: Identify and correct thinking errors",
-                    "🎯 Behavioral Experiments: Test catastrophic beliefs",
-                    "📈 Graded Tasks: Step-by-step overcoming avoidance"
-                ]
-            }
-        },
-        "dbt": {
-            "teen": {
-                "title": "🌊 Emotion Regulation Skills",
-                "exercises": [
-                    "🌊 TIPP: Temperature, Intense exercise, Paced breathing, Paired muscle relaxation",
-                    "🚦 STOP: Stop → Take a breath → Observe → Proceed mindfully",
-                    "🎭 Emotion Diary: Track emotion intensity (1-10) with triggers",
-                    "🧘 Mindfulness: 5-10 minutes daily breathing meditation"
-                ]
-            },
-            "adult": {
-                "title": "⚖️ Dialectical Behavior Therapy",
-                "exercises": [
-                    "⚖️ Wise Mind: Balance emotional and rational mind",
-                    "🛡️ Crisis Skills: TIPP, distraction, self-soothing",
-                    "🤝 DEAR MAN: Technique for healthy communication",
-                    "🎯 Radical Acceptance: Practice accepting unchangeable reality"
-                ]
+    def extract_candle_lighting_times(self, html_content: str, city_name: str) -> Dict[str, Any]:
+        """
+        Extract candle lighting times from Chabad.org HTML content
+        """
+        try:
+            soup = BeautifulSoup(html_content, 'html.parser')
+            
+            # Look for candle lighting time patterns
+            time_patterns = [
+                r'candle lighting[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
+                r'light candles[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
+                r'friday[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
+                r'(\d{1,2}:\d{2}\s*[ap]m?).*candle',
+                r'(\d{1,2}:\d{2}\s*[ap]m?).*light'
+            ]
+            
+            # Look for Havdalah time patterns
+            havdalah_patterns = [
+                r'havdalah[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
+                r'saturday[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
+                r'(\d{1,2}:\d{2}\s*[ap]m?).*havdalah'
+            ]
+            
+            text = soup.get_text().lower()
+            
+            # Find candle lighting time
+            candle_time = None
+            for pattern in time_patterns:
+                match = re.search(pattern, text, re.IGNORECASE)
+                if match:
+                    candle_time = match.group(1)
+                    break
+            
+            # Find Havdalah time
+            havdalah_time = None
+            for pattern in havdalah_patterns:
+                match = re.search(pattern, text, re.IGNORECASE)
+                if match:
+                    havdalah_time = match.group(1)
+                    break
+            
+            # Look for specific elements with common class names/IDs
+            if not candle_time:
+                time_elements = soup.find_all(['span', 'div', 'td'], 
+                                            class_=re.compile(r'time|candle|light', re.I))
+                for element in time_elements:
+                    time_text = element.get_text()
+                    time_match = re.search(r'\d{1,2}:\d{2}(?:\s*[ap]m)?', time_text)
+                    if time_match and not candle_time:
+                        candle_time = time_match.group()
+            
+            # Get current date info
+            now = datetime.datetime.now()
+            friday = now + datetime.timedelta(days=(4 - now.weekday()) % 7)
+            saturday = friday + datetime.timedelta(days=1)
+            
+            return {
+                'city': city_name,
+                'candle_lighting_time': candle_time,
+                'havdalah_time': havdalah_time,
+                'friday_date': friday.strftime('%B %d, %Y'),
+                'saturday_date': saturday.strftime('%B %d, %Y'),
+                'found_data': bool(candle_time or havdalah_time),
+                'raw_text_sample': text[:500] if text else ''
             }
-        },
-        "mindfulness": {
-            "child": {
-                "title": "🐸 Mindfulness for Kids",
-                "exercises": [
-                    "🐸 Frog Pose: Sit still like a frog and listen to sounds",
-                    "🌬️ Belly Breathing: Watch a toy rise and fall on your belly",
-                    "👀 5-4-3-2-1: Find 5 things you see, 4 you hear, 3 you can touch...",
-                    "🍯 Slow Eating: Eat one raisin very slowly and mindfully"
-                ]
-            },
-            "teen": {
-                "title": "🧘 Teen Mindfulness",
-                "exercises": [
-                    "📱 Digital Detox: 30-60 minutes without devices",
-                    "🚶 Mindful Walking: Walk slowly noticing each step",
-                    "💭 Thought Watching: Watch thoughts like clouds passing",
-                    "❤️ Body Scan: Relax and notice each body part"
-                ]
-            },
-            "adult": {
-                "title": "🧘‍♀️ Mindfulness Practice",
-                "exercises": [
-                    "🧘 Formal Meditation: 20-30 minutes daily sitting practice",
-                    "🍽️ Mindful Eating: Full attention to taste, smell, texture",
-                    "💼 Work Mindfulness: Regular pauses to return to present",
-                    "😴 Sleep Meditation: Body scan and breathing for better sleep"
-                ]
+            
+        except Exception as e:
+            print(f"Time extraction error: {e}")
+            return {
+                'city': city_name,
+                'candle_lighting_time': None,
+                'havdalah_time': None,
+                'friday_date': None,
+                'saturday_date': None,
+                'found_data': False,
+                'error': str(e)
             }
-        }
-    }
-    
-    # Get appropriate exercises
-    therapy_data = worksheets.get(therapy_type, {})
-    level_data = therapy_data.get(level, therapy_data.get("adult", {}))
     
-    if not level_data:
-        return f"Exercises for {therapy_type} therapy and age {client_age} not yet available."
-    
-    # Create worksheet
-    worksheet = f"# {level_data['title']}\n\n"
-    worksheet += f"**👤 Client**: {client_age} years old\n"
-    worksheet += f"**🎯 Main issue**: {issue}\n"
-    worksheet += f"**🔬 Therapy type**: {therapy_type.upper()}\n"
-    worksheet += f"**📅 Date created**: {datetime.datetime.now().strftime('%m/%d/%Y')}\n\n"
-    
-    worksheet += "## 📋 Exercises:\n\n"
-    
-    for i, exercise in enumerate(level_data['exercises'], 1):
-        worksheet += f"### {i}. {exercise}\n\n"
+    def get_alternative_times(self, city_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Try alternative sources for Shabbat times
+        """
+        try:
+            # Try MyZmanim API (if available)
+            api_urls = [
+                f"https://www.myzmanim.com/api.aspx?mode=shabbat&city={quote(city_name)}",
+                f"https://www.hebcal.com/shabbat?city={quote(city_name)}&M=on"
+            ]
+            
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+            
+            for url in api_urls:
+                try:
+                    response = requests.get(url, headers=headers, timeout=10)
+                    if response.status_code == 200:
+                        # Try to parse response
+                        if 'json' in response.headers.get('content-type', ''):
+                            data = response.json()
+                            return data
+                        else:
+                            # Parse HTML response
+                            soup = BeautifulSoup(response.text, 'html.parser')
+                            times = self.extract_candle_lighting_times(response.text, city_name)
+                            if times['found_data']:
+                                return times
+                except:
+                    continue
+                    
+        except Exception as e:
+            print(f"Alternative source error: {e}")
         
-        # Add space for notes
-        worksheet += "**📝 Notes:**\n"
-        worksheet += "```\n"
-        worksheet += "Date completed: ___________\n"
-        worksheet += "Observations: \n\n\n"
-        worksheet += "Emotions during exercise: \n\n"
-        worksheet += "Insights: \n\n"
-        worksheet += "```\n\n"
-    
-    worksheet += "---\n\n"
-    worksheet += "## 📖 Instructions:\n"
-    worksheet += "✅ Complete exercises at your own pace\n"
-    worksheet += "✅ Record all observations - this is important for progress\n"
-    worksheet += "✅ Discuss results with your therapist\n"
-    worksheet += "✅ Stop if you feel too uncomfortable and seek support\n\n"
+        return None
     
-    worksheet += "## 🆘 When to get help:\n"
-    worksheet += "⚠️ If exercises cause severe anxiety or panic\n"
-    worksheet += "⚠️ If you have thoughts of self-harm\n"
-    worksheet += "⚠️ If symptoms worsen\n\n"
-    
-    worksheet += "📞 Emergency contacts:\n"
-    worksheet += "- Crisis hotline: 988\n"
-    worksheet += "- Emergency: 101\n"
-    worksheet += "- Your therapist: ________________\n\n"
-    
-    return worksheet
-
-def mood_tracker_analyzer(mood_data_str: str) -> str:
-    """
-    Analyzes mood tracking data to identify patterns.
-    """
-    try:
-        # Try to parse as JSON
-        data = json.loads(mood_data_str)
-    except:
-        # If not JSON, try to parse simple format like "5,7,3,8,6"
+    def get_shabbat_times(self, city_input: str = "", auto_detect: bool = True) -> str:
+        """
+        Main function to get Shabbat candle lighting times
+        """
         try:
-            moods = [float(x.strip()) for x in mood_data_str.split(',')]
-            data = [{"mood": mood, "date": f"Day {i+1}"} for i, mood in enumerate(moods)]
-        except:
-            return "Error: Please provide mood data as JSON or comma-separated numbers (e.g., '5,7,3,8,6')"
-    
-    if not isinstance(data, list) or len(data) == 0:
-        return "Error: Mood data should be a non-empty list of entries."
-    
-    # Analyze mood patterns
-    moods = []
-    dates = []
+            city_name = city_input.strip()
+            
+            # Auto-detect location if requested and no city provided
+            if auto_detect and not city_name:
+                location = self.get_user_location()
+                if location and location.get('city'):
+                    city_name = location['city']
+                    if location.get('country'):
+                        city_name += f", {location['country']}"
+            
+            if not city_name:
+                return self._format_error_response("❌ Please provide a city name or enable location detection.")
+            
+            # Search for the city on Chabad.org
+            city_url = self.search_city_on_chabad(city_name)
+            
+            result_data = None
+            source = "Chabad.org"
+            
+            if city_url:
+                try:
+                    headers = {
+                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+                    }
+                    response = requests.get(city_url, headers=headers, timeout=15)
+                    
+                    if response.status_code == 200:
+                        result_data = self.extract_candle_lighting_times(response.text, city_name)
+                        
+                except Exception as e:
+                    print(f"Chabad.org fetch error: {e}")
+            
+            # Try alternative sources if Chabad.org didn't work
+            if not result_data or not result_data.get('found_data'):
+                alternative_data = self.get_alternative_times(city_name)
+                if alternative_data:
+                    result_data = alternative_data
+                    source = "Alternative source"
+            
+            # Format and return the response
+            if result_data and result_data.get('found_data'):
+                return self._format_success_response(result_data, source, city_url)
+            else:
+                return self._format_not_found_response(city_name)
+                
+        except Exception as e:
+            return self._format_error_response(f"❌ An error occurred: {str(e)}")
     
-    for entry in data:
-        if isinstance(entry, dict) and 'mood' in entry:
-            moods.append(float(entry['mood']))
-            dates.append(entry.get('date', f'Entry {len(dates)+1}'))
-        elif isinstance(entry, (int, float)):
-            moods.append(float(entry))
-            dates.append(f'Entry {len(dates)+1}')
+    def _format_success_response(self, data: Dict[str, Any], source: str, url: str = None) -> str:
+        """Format successful response with Shabbat times"""
+        response = f"""
+# 🕯️ Shabbat Candle Lighting Times
+
+## 📍 Location: {data.get('city', 'Unknown')}
+
+### 🕯️ **Candle Lighting (Friday)**
+**Time:** {data.get('candle_lighting_time', 'Not found')}
+**Date:** {data.get('friday_date', 'This Friday')}
+
+### ⭐ **Havdalah (Saturday)**
+**Time:** {data.get('havdalah_time', 'Not found')}
+**Date:** {data.get('saturday_date', 'This Saturday')}
+
+---
+
+## 📋 **Important Notes:**
+- 🕯️ Light Shabbat candles **18 minutes before sunset** on Friday
+- ⭐ Havdalah is performed after **3 stars appear** on Saturday night
+- 🌍 Times are specific to your geographic location
+- ⏰ Always verify times with your local rabbi or Jewish community
+
+## 📚 **Source Information:**
+**Data from:** {source}
+**Retrieved:** {datetime.datetime.now().strftime('%B %d, %Y at %I:%M %p')}
+{f"**URL:** {url}" if url else ""}
+
+---
+
+## 🙏 **Shabbat Shalom!**
+*May your Shabbat be filled with peace, joy, and spiritual connection.*
+"""
+        return response
+    
+    def _format_not_found_response(self, city_name: str) -> str:
+        """Format response when times are not found"""
+        return f"""
+# 🕯️ Shabbat Candle Lighting Times
+
+## ❌ Times Not Found
+
+Unfortunately, we couldn't find specific Shabbat candle lighting times for **{city_name}**.
+
+### 🔍 **What you can try:**
+1. **Check spelling** - Make sure the city name is spelled correctly
+2. **Add country** - Try "City, Country" format (e.g., "Paris, France")
+3. **Use major city** - Try the nearest major city instead
+4. **Manual lookup** - Visit [Chabad.org](https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm) directly
+
+### 📍 **General Guidelines:**
+- 🕯️ **Candle lighting:** Typically 18 minutes before sunset on Friday
+- ⭐ **Havdalah:** Approximately 25-42 minutes after sunset on Saturday
+- 🌍 **Location matters:** Times vary significantly by geographic location
+
+### 📞 **Local Resources:**
+- Contact your local Chabad house or synagogue
+- Check with your Jewish community center
+- Consult your rabbi for precise local customs
+
+---
+
+**Retrieved:** {datetime.datetime.now().strftime('%B %d, %Y at %I:%M %p')}
+"""
     
-    if not moods:
-        return "Error: No valid mood entries found."
+    def _format_error_response(self, error_message: str) -> str:
+        """Format error response"""
+        return f"""
+# 🕯️ Shabbat Candle Lighting Times
+
+## ⚠️ Error
+
+{error_message}
+
+### 🔄 **Please try:**
+1. **Refresh** and try again
+2. **Check internet connection**
+3. **Use a different city name**
+4. **Visit Chabad.org directly:** [Candle Lighting Times](https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm)
+
+---
+
+**Time:** {datetime.datetime.now().strftime('%B %d, %Y at %I:%M %p')}
+"""
+
+def create_shabbat_interface():
+    """Create the Gradio interface for the Shabbat Candle Lighting Agent"""
     
-    # Calculate statistics
-    avg_mood = sum(moods) / len(moods)
-    mood_trend = "stable"
+    agent = ShabbatCandleLightingAgent()
     
-    if len(moods) > 3:
-        recent_avg = sum(moods[-3:]) / 3
-        older_avg = sum(moods[:-3]) / (len(moods) - 3)
+    with gr.Blocks(title="🕯️ Shabbat Candle Lighting Times", theme=gr.themes.Soft()) as app:
         
-        if recent_avg > older_avg + 0.5:
-            mood_trend = "improving"
-        elif recent_avg < older_avg - 0.5:
-            mood_trend = "declining"
-    
-    # Create report
-    report = "# 📊 Mood Tracking Analysis\n\n"
-    report += f"**Period**: {dates[0]} to {dates[-1]}\n"
-    report += f"**Entries analyzed**: {len(moods)}\n"
-    report += f"**Average mood**: {avg_mood:.1f}/10\n"
-    report += f"**Trend**: {mood_trend}\n\n"
-    
-    report += "## 📈 Pattern Analysis:\n"
-    
-    # Check for low mood periods
-    low_mood_days = sum(1 for m in moods if m < 5)
-    if low_mood_days > len(moods) * 0.3:
-        report += "⚠️ Concern: Low mood detected in >30% of entries\n"
-        report += "   → Consider professional evaluation for depression\n\n"
-    
-    # Check volatility
-    if len(moods) > 2:
-        volatility = sum(abs(moods[i] - moods[i-1]) for i in range(1, len(moods))) / (len(moods) - 1)
-        if volatility > 2:
-            report += "🎢 High mood volatility detected\n"
-            report += "   → May benefit from emotion regulation skills\n\n"
-    
-    report += "## 💡 Recommendations:\n"
-    
-    if mood_trend == "declining":
-        report += "- 🚨 Schedule appointment with mental health professional\n"
-        report += "- 🧘 Increase self-care activities\n"
-        report += "- 👥 Reach out to support network\n"
-    elif mood_trend == "improving":
-        report += "- ✅ Continue current strategies\n"
-        report += "- 📝 Document what's working well\n"
-        report += "- 🎯 Set new wellness goals\n"
-    else:
-        report += "- 📊 Continue tracking for more data\n"
-        report += "- 🔍 Look for mood triggers\n"
-        report += "- 💪 Maintain healthy routines\n"
-    
-    report += f"\n*Analysis completed: {datetime.datetime.now().strftime('%m/%d/%Y %H:%M')}*"
-    
-    return report
-
-# Create the Gradio interface
-def create_interface():
-    """Create and return the Gradio interface"""
-    
-    with gr.Blocks(title="🧠 Mental Health Therapy Assistant", theme=gr.themes.Soft()) as app:
         gr.Markdown("""
-        # 🧠 Mental Health Therapy Assistant
+        # 🕯️ Shabbat Candle Lighting Times AI Agent
+        
+        **Get accurate Shabbat candle lighting and Havdalah times for any city worldwide**
         
-        **⚠️ Important Disclaimer**: This tool is for educational and supportive purposes only. 
-        It is not a substitute for professional mental health care. If you're in crisis, 
-        please contact emergency services (911) or the crisis hotline (988).
+        This AI agent searches Chabad.org and other reliable sources to find precise Jewish ritual times for your location.
         """)
         
-        with gr.Tabs():
-            # Emotion Analysis Tab
-            with gr.TabItem("🎭 Emotion Analysis"):
-                gr.Markdown("### Analyze emotional content from speech or text")
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 📍 Location Input")
                 
-                with gr.Row():
-                    with gr.Column():
-                        emotion_text = gr.Textbox(
-                            label="Patient Speech/Text",
-                            placeholder="Enter the text you want to analyze for emotional content...",
-                            lines=5
-                        )
-                        emotion_context = gr.Dropdown(
-                            choices=["therapy", "assessment", "crisis"],
-                            value="therapy",
-                            label="Context"
-                        )
-                        emotion_btn = gr.Button("🔍 Analyze Emotions", variant="primary")
-                    
-                    with gr.Column():
-                        emotion_output = gr.Markdown(label="Analysis Results")
-                
-                emotion_btn.click(
-                    fn=speech_emotion_analyzer,
-                    inputs=[emotion_text, emotion_context],
-                    outputs=emotion_output
+                city_input = gr.Textbox(
+                    label="🏙️ City Name",
+                    placeholder="Enter city name (e.g., 'New York', 'London', 'Tel Aviv', 'Paris, France')",
+                    info="Leave empty to auto-detect your location"
                 )
-            
-            # Worksheet Generator Tab
-            with gr.TabItem("📝 Therapy Worksheets"):
-                gr.Markdown("### Generate age-appropriate therapeutic exercises")
                 
-                with gr.Row():
-                    with gr.Column():
-                        worksheet_therapy = gr.Dropdown(
-                            choices=["CBT", "DBT", "Art", "Mindfulness"],
-                            value="CBT",
-                            label="Therapy Type"
-                        )
-                        worksheet_age = gr.Slider(
-                            minimum=5,
-                            maximum=100,
-                            value=25,
-                            step=1,
-                            label="Client Age"
-                        )
-                        worksheet_issue = gr.Textbox(
-                            label="Main Issue/Concern",
-                            placeholder="e.g., anxiety, depression, anger management..."
-                        )
-                        worksheet_btn = gr.Button("📋 Generate Worksheet", variant="primary")
-                    
-                    with gr.Column():
-                        worksheet_output = gr.Markdown(label="Generated Worksheet")
-                
-                worksheet_btn.click(
-                    fn=create_therapy_worksheet,
-                    inputs=[worksheet_therapy, worksheet_age, worksheet_issue],
-                    outputs=worksheet_output
+                auto_detect = gr.Checkbox(
+                    label="🌐 Auto-detect my location",
+                    value=True,
+                    info="Automatically find your location if no city is entered"
                 )
-            
-            # Mood Tracker Tab
-            with gr.TabItem("📊 Mood Analysis"):
-                gr.Markdown("### Analyze mood tracking patterns")
-                
-                with gr.Row():
-                    with gr.Column():
-                        mood_data = gr.Textbox(
-                            label="Mood Data",
-                            placeholder="Enter mood scores (1-10) separated by commas: 5,7,3,8,6\nOr JSON format: [{\"mood\": 5, \"date\": \"2024-01-01\"}, ...]",
-                            lines=5
-                        )
-                        mood_btn = gr.Button("📈 Analyze Mood Patterns", variant="primary")
-                        
-                        gr.Markdown("""
-                        **Example formats:**
-                        - Simple: `5,7,3,8,6,4,9`
-                        - JSON: `[{"mood": 5, "date": "2024-01-01"}, {"mood": 7, "date": "2024-01-02"}]`
-                        """)
-                    
-                    with gr.Column():
-                        mood_output = gr.Markdown(label="Mood Analysis Results")
                 
-                mood_btn.click(
-                    fn=mood_tracker_analyzer,
-                    inputs=mood_data,
-                    outputs=mood_output
+                search_btn = gr.Button(
+                    "🔍 Get Shabbat Times",
+                    variant="primary",
+                    size="lg"
                 )
-            
-            # Resources Tab
-            with gr.TabItem("📚 Resources"):
-                gr.Markdown("""
-                ### 🆘 Crisis Resources
-                
-                **Immediate Help:**
-                - 🚨 Emergency: **911**
-                - 📞 Crisis Hotline: **988** (Suicide & Crisis Lifeline)
-                - 💬 Crisis Text Line: Text HOME to **741741**
                 
-                **Online Resources:**
-                - [National Alliance on Mental Illness (NAMI)](https://nami.org)
-                - [Mental Health America](https://www.mhanational.org)
-                - [Psychology Today Therapist Finder](https://www.psychologytoday.com)
-                
-                ### 🧘 Self-Care Tips
-                
-                **Daily Practices:**
-                - 🌅 Maintain regular sleep schedule
-                - 🏃 Regular physical activity
-                - 🥗 Balanced nutrition
-                - 🧘 Mindfulness/meditation practice
-                - 👥 Social connections
-                - 📚 Limit news/social media if overwhelming
-                
-                **Remember:** This tool provides educational support but cannot replace professional mental health care.
+                gr.Markdown("""
+                ### 💡 **Tips:**
+                - Use full city names for better results
+                - Include country for common city names (e.g., "Paris, France")
+                - Try nearest major city if your city isn't found
                 """)
+        
+            with gr.Column():
+                output_area = gr.Markdown(
+                    label="📋 Shabbat Times Results",
+                    value="👆 Enter a city name and click 'Get Shabbat Times' to begin"
+                )
+        
+        # Example buttons for popular cities
+        gr.Markdown("### 🌍 Quick Search - Popular Cities:")
+        
+        with gr.Row():
+            examples = [
+                ["New York", False],
+                ["London", False], 
+                ["Jerusalem", False],
+                ["Los Angeles", False],
+                ["Tel Aviv", False],
+                ["Miami", False]
+            ]
+            
+            example_btns = []
+            for city, auto in examples:
+                btn = gr.Button(f"📍 {city}", size="sm")
+                example_btns.append(btn)
+        
+        # Button click handlers
+        search_btn.click(
+            fn=agent.get_shabbat_times,
+            inputs=[city_input, auto_detect],
+            outputs=output_area
+        )
+        
+        # Example button handlers
+        for i, (city, auto) in enumerate(examples):
+            example_btns[i].click(
+                fn=lambda c=city: agent.get_shabbat_times(c, False),
+                outputs=output_area
+            )
+        
+        # Resources and information
+        with gr.Accordion("📚 Resources & Information", open=False):
+            gr.Markdown("""
+            ### 🕯️ **About Shabbat Candle Lighting:**
+            
+            **Candle Lighting Time:**
+            - Performed on Friday evening before sunset
+            - Typically 18 minutes before sunset (varies by community)
+            - Marks the beginning of Shabbat
+            
+            **Havdalah Time:**
+            - Performed on Saturday evening after sunset
+            - When three medium-sized stars are visible in the sky
+            - Marks the end of Shabbat
+            
+            ### 🌐 **Data Sources:**
+            - Primary: [Chabad.org](https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm)
+            - Alternative sources for backup
+            - Local astronomical calculations
+            
+            ### ⚠️ **Important:**
+            - Always consult your local rabbi for specific customs
+            - Times may vary based on local Jewish community practices
+            - This tool is for reference only
+            """)
+        
+        gr.Markdown("""
+        ---
+        
+        **🙏 Shabbat Shalom!** | Built with ❤️ for the Jewish community worldwide
+        
+        *For questions or issues, please consult your local Jewish community or rabbi.*
+        """)
     
     return app
 
 # Main execution
 if __name__ == "__main__":
-    # Create and launch the interface
-    app = create_interface()
+    app = create_shabbat_interface()
     
-    # Launch with appropriate settings for deployment
+    # Launch the application
     app.launch(
-        server_name="0.0.0.0",  # Allow external access
-        server_port=7860,       # Standard port for Hugging Face Spaces
-        share=False,            # Don't create a public link
-        debug=False             # Disable debug mode for production
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=False,
+        show_error=True
     )