Blame for app.py

import gradio as gr
import requests
import json
import datetime
import re
from bs4 import BeautifulSoup
from typing import Optional, Dict, Any
from urllib.parse import quote, urljoin

class ShabbatCandleLightingAgent:
    """
    AI Agent for finding Shabbat candle lighting times worldwide using Chabad.org
    """
    
    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"
    
    def get_user_ip_location(self) -> Optional[Dict[str, Any]]:
        """
        Enhanced IP-based location detection using multiple high-quality services
        """
        try:
            # Enhanced list of location services with better accuracy
            services = [
                {
                    "url": "https://ipapi.co/json/",
                    "parser": "ipapi_co",
                    "accuracy": "high"
                },
                {
                    "url": "http://ip-api.com/json/?fields=status,message,country,countryCode,region,regionName,city,zip,lat,lon,timezone,isp,query",
                    "parser": "ip_api", 
                    "accuracy": "medium"
                },
                {
                    "url": "https://ipgeolocation.abstractapi.com/v1/?api_key=free",
                    "parser": "abstractapi",
                    "accuracy": "high"
                },
                {
                    "url": "https://freegeoip.app/json/",
                    "parser": "freegeoip",
                    "accuracy": "medium"
                },
                {
                    "url": "https://api.ipify.org?format=json",
                    "parser": "ipify_then_geocode",
                    "accuracy": "low"
                }
            ]
            
            best_result = None
            all_results = []
            
            for service in services:
                try:
                    headers = {
                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
                        'Accept': 'application/json',
                        'Accept-Language': 'en-US,en;q=0.9'
                    }
                    
                    response = requests.get(service["url"], headers=headers, timeout=8)
                    if response.status_code == 200:
                        data = response.json()
                        parsed_location = self._parse_ip_location_data(data, service["parser"])
                        
                        if parsed_location and parsed_location.get('city'):
                            parsed_location['accuracy_level'] = service["accuracy"]
                            parsed_location['source'] = service["parser"]
                            all_results.append(parsed_location)
                            print(f"✅ {service['parser']}: {parsed_location['city']}, {parsed_location.get('country', '')}")
                            
                            # Keep the best result (prefer high accuracy sources)
                            if not best_result or service["accuracy"] == "high":
                                best_result = parsed_location
                        
                except Exception as e:
                    print(f"❌ Service {service['parser']} failed: {e}")
                    continue
            
            # Return best result with confidence assessment
            if best_result:
                best_result['all_results'] = all_results
                best_result['confidence'] = self._assess_location_confidence(all_results)
                print(f"🎯 Best location: {best_result['city']}, {best_result.get('country', '')} (confidence: {best_result['confidence']})")
                return best_result
                
        except Exception as e:
            print(f"Location detection error: {e}")
        
        return None
    
    def _parse_ip_location_data(self, data: dict, parser_type: str) -> Optional[Dict[str, Any]]:
        """Parse location data from different IP geolocation APIs"""
        try:
            if parser_type == "ipapi_co":
                if data.get('city') and not data.get('error'):
                    return {
                        'city': data.get('city'),
                        'country': data.get('country_name'),
                        'region': data.get('region'),
                        'lat': data.get('latitude'),
                        'lng': data.get('longitude'),
                        'timezone': data.get('timezone'),
                        'isp': data.get('org')
                    }
            
            elif parser_type == "ip_api":
                if data.get('status') == 'success':
                    return {
                        'city': data.get('city'),
                        'country': data.get('country'),
                        'region': data.get('regionName'),
                        'lat': data.get('lat'),
                        'lng': data.get('lon'),
                        'timezone': data.get('timezone'),
                        'isp': data.get('isp')
                    }
            
            elif parser_type == "abstractapi":
                if data.get('city') and not data.get('error'):
                    return {
                        'city': data.get('city'),
                        'country': data.get('country'),
                        'region': data.get('region'),
                        'lat': data.get('latitude'),
                        'lng': data.get('longitude'),
                        'timezone': data.get('timezone', {}).get('name') if isinstance(data.get('timezone'), dict) else data.get('timezone'),
                        'isp': data.get('connection', {}).get('isp_name') if isinstance(data.get('connection'), dict) else None
                    }
            
            elif parser_type == "freegeoip":
                if data.get('city'):
                    return {
                        'city': data.get('city'),
                        'country': data.get('country_name'),
                        'region': data.get('region_name'),
                        'lat': data.get('latitude'),
                        'lng': data.get('longitude'),
                        'timezone': data.get('time_zone')
                    }
                    
        except Exception as e:
            print(f"Parse error for {parser_type}: {e}")
        
        return None
    
    def _assess_location_confidence(self, all_results: list) -> str:
        """Assess confidence level based on multiple results"""
        if len(all_results) == 0:
            return "none"
        elif len(all_results) == 1:
            return "low"
        
        # Check if multiple services agree on the city
        cities = [result.get('city', '').lower() for result in all_results if result.get('city')]
        unique_cities = set(cities)
        
        if len(unique_cities) == 1 and len(cities) >= 2:
            return "high"
        elif len(unique_cities) <= 2 and len(cities) >= 2:
            return "medium"
        else:
            return "low"
        """
        Search for a city on Chabad.org and get the specific URL for candle lighting times
        """
        try:
            # Clean and format city name
            city_clean = city_name.strip()
            search_query = quote(city_clean)
            
            headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
                'Accept-Language': 'en-US,en;q=0.5',
                'Accept-Encoding': 'gzip, deflate',
                'Connection': 'keep-alive',
                'Upgrade-Insecure-Requests': '1'
            }
            
            # Try different search approaches for Chabad.org
            search_strategies = [
                # Direct city page approach
                f"https://www.chabad.org/calendar/candlelighting_cdo/jewish/{search_query}.htm",
                # Search with city parameter
                f"https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm?city={search_query}",
                # Alternative format
                f"https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Candle-Lighting-Times-{search_query}.htm",
                # General search
                f"https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm"
            ]
            
            for url in search_strategies:
                try:
                    response = requests.get(url, headers=headers, timeout=15)
                    if response.status_code == 200:
                        # Check if the response contains candle lighting information
                        content_lower = response.text.lower()
                        if any(keyword in content_lower for keyword in ['candle lighting', 'light candles', 'shabbat', 'friday']):
                            return url
                except Exception as e:
                    print(f"Failed to fetch {url}: {e}")
                    continue
            
            # Try POST request to the main search page
            try:
                post_data = {
                    'city': city_clean,
                    'submit': 'Get Times'
                }
                response = requests.post(self.candle_lighting_url, data=post_data, headers=headers, timeout=15)
                if response.status_code == 200 and 'candle lighting' in response.text.lower():
                    return response.url
            except Exception as e:
                print(f"POST request failed: {e}")
                
        except Exception as e:
            print(f"City search error: {e}")
        
        return self.candle_lighting_url  # Return main page as fallback
    
    def extract_candle_lighting_times(self, html_content: str, city_name: str) -> Dict[str, Any]:
        """
        Extract candle lighting times from Chabad.org HTML content using multiple strategies
        """
        try:
            soup = BeautifulSoup(html_content, 'html.parser')
            text = soup.get_text().lower()
            
            # Multiple patterns to find candle lighting times
            candle_patterns = [
                r'candle\s+lighting[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
                r'light\s+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)',
                r'(\d{1,2}:\d{2}\s*[ap]m?)(?=.*friday)'
            ]
            
            # Patterns for Havdalah times
            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)',
                r'(\d{1,2}:\d{2}\s*[ap]m?)(?=.*saturday)'
            ]
            
            # Find candle lighting time
            candle_time = None
            for pattern in candle_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 times in common HTML elements
            if not candle_time or not havdalah_time:
                # Check for time elements with specific classes or IDs
                time_selectors = [
                    '[class*="time"]',
                    '[class*="candle"]',
                    '[class*="light"]',
                    '[id*="time"]',
                    '[id*="candle"]',
                    'td', 'span', 'div'
                ]
                
                for selector in time_selectors:
                    elements = soup.select(selector)
                    for element in elements:
                        element_text = element.get_text().strip()
                        time_match = re.search(r'\d{1,2}:\d{2}(?:\s*[ap]m)?', element_text, re.IGNORECASE)
                        if time_match:
                            time_found = time_match.group()
                            if not candle_time and any(word in element_text.lower() for word in ['candle', 'light', 'friday']):
                                candle_time = time_found
                            elif not havdalah_time and any(word in element_text.lower() for word in ['havdalah', 'saturday']):
                                havdalah_time = time_found
            
            # Calculate current Shabbat dates
            now = datetime.datetime.now()
            days_until_friday = (4 - now.weekday()) % 7
            if days_until_friday == 0 and now.hour >= 18:  # If it's Friday evening, get next Friday
                days_until_friday = 7
            
            friday = now + datetime.timedelta(days=days_until_friday)
            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),
                'search_successful': True
            }
            
        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,
                'search_successful': False,
                'error': str(e)
            }
    
    def get_backup_times(self, city_name: str) -> Optional[Dict[str, Any]]:
        """
        Try alternative sources for Shabbat times when Chabad.org fails
        """
        try:
            # Alternative Jewish calendar websites
            backup_urls = [
                f"https://www.hebcal.com/shabbat?city={quote(city_name)}",
                f"https://www.myzmanim.com/search.aspx?city={quote(city_name)}"
            ]
            
            headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
            }
            
            for url in backup_urls:
                try:
                    response = requests.get(url, headers=headers, timeout=10)
                    if response.status_code == 200:
                        times = self.extract_candle_lighting_times(response.text, city_name)
                        if times.get('found_data'):
                            times['source'] = 'backup'
                            return times
                except Exception as e:
                    print(f"Backup source {url} failed: {e}")
                    continue
                    
        except Exception as e:
            print(f"Backup sources error: {e}")
        
        return None
    
    def get_shabbat_times(self, city_input: str = "", auto_detect: bool = False) -> str:
        """
        Main function to get Shabbat candle lighting times
        """
        try:
            city_name = city_input.strip()
            location_info = ""
            
            # Auto-detect location using enhanced IP geolocation if requested
            if auto_detect and not city_name:
                print("🔍 Attempting to detect your location using IP geolocation...")
                location = self.get_user_ip_location()
                if location and location.get('city'):
                    city_name = location['city']
                    if location.get('country') and location['country'] not in city_name:
                        city_name += f", {location['country']}"
                    
                    # Add location detection info
                    confidence = location.get('confidence', 'unknown')
                    source = location.get('source', 'unknown')
                    
                    if confidence == 'high':
                        status_icon = "✅"
                        status_text = "High confidence"
                    elif confidence == 'medium':
                        status_icon = "⚠️"
                        status_text = "Medium confidence - please verify"
                    else:
                        status_icon = "🔍"
                        status_text = "Low confidence - may be inaccurate"
                    
                    location_info = f"""
**🌐 IP-Based Location Detection:**
{status_icon} **Detected:** {city_name}  
**Confidence:** {status_text}  
**Source:** {source}  

{('⚠️ *Note: IP location shows your internet provider\'s location, not exact address. For most accurate results, enter your city manually.*' if confidence != 'high' else '✅ *Multiple services confirmed this location*')}

---
"""
            
            if not city_name:
                return self._format_error_response("❌ Please enter a city name or enable auto-detection to search for Shabbat times.")
            
            # Search Chabad.org for the city
            print(f"🔍 Searching for Shabbat times in: {city_name}")
            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/120.0.0.0 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)
                        print(f"📊 Extraction result: {result_data}")
                        
                except Exception as e:
                    print(f"❌ Chabad.org fetch error: {e}")
            
            # Try backup sources if Chabad.org didn't work well
            if not result_data or not result_data.get('found_data'):
                print("🔄 Trying backup sources...")
                backup_data = self.get_backup_times(city_name)
                if backup_data and backup_data.get('found_data'):
                    result_data = backup_data
                    source = "Alternative Jewish calendar source"
            
            # Format and return the response
            if result_data and result_data.get('found_data'):
                response = self._format_success_response(result_data, source, city_url)
                return location_info + response
            else:
                response = self._format_not_found_response(city_name, city_url)
                return location_info + response
                
        except Exception as e:
            print(f"Main function error: {e}")
            return self._format_error_response(f"❌ An error occurred: {str(e)}")
    
    def _format_geolocation_instructions(self) -> str:
        """Instructions for using browser geolocation"""
        return f"""
# 🕯️ Shabbat Candle Lighting Times

## 📍 Automatic Location Detection

To automatically detect your location, we need access to your device's GPS. Please follow these steps:

### 🔒 **Step 1: Enable Location Access**
1. Click the **"🌐 Get My Location"** button below
2. Your browser will ask for permission to access your location
3. Click **"Allow"** in the permission popup
4. Wait for your coordinates to be detected

### 📱 **Step 2: Location will be converted to city**
Once we get your GPS coordinates, we'll:
- Convert them to the nearest city name
- Automatically search for Shabbat times
- Display the results for your location

### ⚠️ **Privacy Note:**
- Your location is only used to find the nearest city
- No location data is stored or shared
- You can deny permission and enter your city manually instead

### 🌐 **Location Requirements:**
- **HTTPS connection** (secure website)
- **GPS-enabled device** (phone, tablet, or laptop with location services)
- **Browser permission** for location access

---

**Manual Alternative:** Enter your city name in the field above if you prefer not to share your location.

**Date:** {datetime.datetime.now().strftime('%B %d, %Y at %I:%M %p')}
"""
    
    def _format_success_response(self, data: Dict[str, Any], source: str, url: str = None) -> str:
        """Format successful response with Shabbat times"""
        candle_time = data.get('candle_lighting_time', 'Not found')
        havdalah_time = data.get('havdalah_time', 'Not found')
        
        response = f"""
# 🕯️ Shabbat Candle Lighting Times

## 📍 Location: {data.get('city', 'Unknown')}

### 🕯️ **Candle Lighting (Friday)**
**Time:** {candle_time}  
**Date:** {data.get('friday_date', 'This Friday')}

### ⭐ **Havdalah (Saturday)**
**Time:** {havdalah_time}  
**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.*

**🔔 Reminder:** Set an alarm 30 minutes before candle lighting time to prepare properly.
"""
        return response
    
    def _format_not_found_response(self, city_name: str, url: str = None) -> str:
        """Format response when times are not found"""
        return f"""
# 🕯️ Shabbat Candle Lighting Times

## ❌ Times Not Found for {city_name}

We searched multiple sources but 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. **Alternative spellings** - Try different variations of the city name

### 📍 **General Guidelines for {city_name}:**
- 🕯️ **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

### 🌐 **Manual Resources:**
- 📱 **Chabad.org:** [Direct search]({url or 'https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm'})
- 📱 **Hebcal.com:** Alternative Jewish calendar
- 📞 **Local contacts:** Your synagogue or Chabad house

### 📞 **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')}
"""
    
    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)

### 📞 **Alternative:**
Contact your local synagogue or Chabad house for accurate times.

---

**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"""
    
    agent = ShabbatCandleLightingAgent()
    
    with gr.Blocks(title="🕯️ Shabbat Candle Lighting Times", theme=gr.themes.Soft()) as app:
        
        gr.Markdown("""
        # 🕯️ Shabbat Candle Lighting Times AI Agent
        
        **Get accurate Shabbat candle lighting and Havdalah times for any city worldwide**
        
        This AI agent searches Chabad.org and other reliable Jewish sources to find precise ritual times for your location.
        
        ---
        """)
        
        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### 📍 Location Input")
                
                city_input = gr.Textbox(
                    label="🏙️ City Name",
                    placeholder="Enter city name (e.g., 'New York', 'London, UK', 'Tel Aviv, Israel')",
                    info="Enter manually or use automatic location detection below",
                    lines=1
                )
                
                # Add IP-based geolocation detection
                with gr.Row():
                    detect_ip_btn = gr.Button(
                        "🌐 Auto-Detect (IP Location)",
                        variant="secondary",
                        size="sm"
                    )
                    search_btn = gr.Button(
                        "🔍 Get Shabbat Times",
                        variant="primary",
                        size="sm"
                    )
                
                gr.Markdown("""
                ### 💡 **How to Use:**
                
                **🅰️ Manual Entry** (Most Accurate)
                - Enter your city name above and click "Get Shabbat Times"
                - Use format: "City, Country" for best results
                
                **🅱️ Auto-Detection** (Uses Your IP Location)
                - Click "Auto-Detect" to automatically find your approximate location
                - ⚠️ Note: IP location shows your internet provider's area, not exact address
                - May be off by 10-50 km from your actual location
                
                ### 🇮🇱 **Popular Israeli Cities:**
                Jerusalem, Tel Aviv, Haifa, Beer Sheva, Netanya, Ashdod
                
                ### 🌍 **International Examples:**
                London, UK • Paris, France • New York, USA • Toronto, Canada
                """)
        
            with gr.Column(scale=2):
                output_area = gr.Markdown(
                    label="📋 Shabbat Times Results",
                    value="""
# 🕯️ Welcome!

### 🎯 **Two Ways to Find Shabbat Times:**

**🅰️ Manual Entry** (Most Reliable)
👆 Enter your city name above and click "Get Shabbat Times"

**🅱️ Auto-Detection** (Uses IP Geolocation)
👆 Click "Auto-Detect" to find your approximate location via internet provider

### 🇮🇱 **Common Israeli Cities:**
Use: Jerusalem, Tel Aviv, Haifa, Beer Sheva, Netanya, Ashdod

### 🌍 **International Cities:**  
Format: London, UK • Paris, France • New York, USA

---

**🕯️ Every Friday evening, Jewish families around the world light candles to welcome Shabbat**

**⚠️ Note:** Auto-detection uses IP location (approximate) - for best accuracy, enter city manually
                    """
                )
        
        # Example buttons for popular cities
        gr.Markdown("### 🌍 Quick Search - Popular Cities:")
        
        with gr.Row():
            # Israeli cities first for the detected user
            popular_cities = [
                "Jerusalem, Israel",
                "Tel Aviv, Israel", 
                "Haifa, Israel",
                "Beer Sheva, Israel",
                "Netanya, Israel",
                "Ashdod, Israel",
                # International cities
                "New York, NY",
                "London, UK",
                "Paris, France",
                "Toronto, Canada",
                "Los Angeles, CA",
                "Miami, FL"
            ]
            
            example_btns = []
            for i in range(0, len(popular_cities), 4):
                with gr.Row():
                    for city in popular_cities[i:i+4]:
                        btn = gr.Button(f"📍 {city}", size="sm")
                        example_btns.append((btn, city))
        
        # Button click handlers 
        search_btn.click(
            fn=agent.get_shabbat_times,
            inputs=[city_input, gr.State(False)],  # auto_detect = False for manual search
            outputs=output_area
        )
        
        # IP-based auto-detection
        detect_ip_btn.click(
            fn=agent.get_shabbat_times,
            inputs=[gr.State(""), gr.State(True)],  # empty city, auto_detect = True
            outputs=output_area
        )
        
        # Example button handlers
        for btn, city in example_btns:
            btn.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
            - Usually done by the woman of the house
            
            **Havdalah Time:**
            - Performed on Saturday evening after sunset
            - When three medium-sized stars are visible in the sky
            - Marks the end of Shabbat
            - Includes blessings over wine, spices, and candle
            
            ### 🌐 **Data Sources:**
            - **Primary:** [Chabad.org](https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm)
            - **Backup:** Hebcal.com and other Jewish calendar sites
            - **Method:** Intelligent web scraping with multiple fallback strategies
            
            ### ⚠️ **Important Disclaimers:**
            - Always consult your local rabbi for specific customs
            - Times may vary based on local Jewish community practices  
            - This tool is for reference only - not a substitute for religious guidance
            - Some communities light candles at different intervals before sunset
            
            ### 🔧 **Technical Features:**
            - **Browser GPS Geolocation** - Uses your device's actual GPS hardware
            - **Reverse Geocoding** - Converts GPS coordinates to city names
            - **Multiple search strategies** for maximum success on Chabad.org
            - **Intelligent pattern matching** to extract candle lighting times
            - **Fallback to alternative sources** if needed
            - **Privacy-focused** - location data never stored or shared
            """)
        
        gr.Markdown("""
        ---
        
        **🙏 Shabbat Shalom!** | Built with ❤️ for the global Jewish community
        
        *For questions about Jewish law or local customs, please consult your rabbi or local Jewish community.*
        """)
    
    return app

# Main execution
if __name__ == "__main__":
    app = create_shabbat_interface()
    
    # Launch the application
    app.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False,
        debug=False,
        show_error=True
    )