Update app.py

app.py

@@ -16,7 +16,154 @@ class ShabbatCandleLightingAgent:
         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 search_city_on_chabad(self, city_name: str) -> Optional[str]:
+    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
         """
@@ -205,15 +352,50 @@ class ShabbatCandleLightingAgent:
         
         return None
     
-    def get_shabbat_times(self, city_input: str = "") -> str:
+    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 to search for Shabbat times.")
+                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}")
@@ -246,14 +428,54 @@ class ShabbatCandleLightingAgent:
             
             # Format and return the response
             if result_data and result_data.get('found_data'):
-                return self._format_success_response(result_data, source, city_url)
+                response = self._format_success_response(result_data, source, city_url)
+                return location_info + response
             else:
-                return self._format_not_found_response(city_name, city_url)
+                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')
@@ -376,26 +598,37 @@ def create_shabbat_interface():
                 city_input = gr.Textbox(
                     label="🏙️ City Name",
                     placeholder="Enter city name (e.g., 'New York', 'London, UK', 'Tel Aviv, Israel')",
-                    info="Please enter your city name to get accurate Shabbat times",
+                    info="Enter manually or use automatic location detection below",
                     lines=1
                 )
                 
-                search_btn = gr.Button(
-                    "🔍 Get Shabbat Times",
-                    variant="primary",
-                    size="lg"
-                )
+                # 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("""
-                ### 💡 **City Input Tips:**
-                - Use full city names for better results
-                - Add country for common city names (e.g., "Paris, France")
-                - Try nearest major city if yours isn't found
-                - Use English city names for best search results
+                ### 💡 **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, 
-                Petah Tikva, Ramat Gan, Bnei Brak, Herzliya
+                Jerusalem, Tel Aviv, Haifa, Beer Sheva, Netanya, Ashdod
                 
                 ### 🌍 **International Examples:**
                 London, UK • Paris, France • New York, USA • Toronto, Canada
@@ -407,19 +640,25 @@ def create_shabbat_interface():
                     value="""
 # 🕯️ Welcome!
 
-👆 **Enter your city name above and click 'Get Shabbat Times'**
+### 🎯 **Two Ways to Find Shabbat Times:**
 
-Or click one of the popular cities below for a quick search.
+**🅰️ 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 any of these city names: Jerusalem, Tel Aviv, Haifa, Beer Sheva, Netanya, Ashdod
+Use: Jerusalem, Tel Aviv, Haifa, Beer Sheva, Netanya, Ashdod
 
 ### 🌍 **International Cities:**  
-Include country name: London, UK • Paris, France • New York, USA
+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
                     """
                 )
         
@@ -451,17 +690,24 @@ Include country name: London, UK • Paris, France • New York, USA
                         btn = gr.Button(f"📍 {city}", size="sm")
                         example_btns.append((btn, city))
         
-        # Button click handlers
+        # Button click handlers 
         search_btn.click(
             fn=agent.get_shabbat_times,
-            inputs=[city_input],
+            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),
+                fn=lambda c=city: agent.get_shabbat_times(c, False),
                 outputs=output_area
             )
         
@@ -494,10 +740,12 @@ Include country name: London, UK • Paris, France • New York, USA
             - Some communities light candles at different intervals before sunset
             
             ### 🔧 **Technical Features:**
-            - Multiple search strategies for maximum success on Chabad.org
-            - Intelligent pattern matching to extract candle lighting times
-            - Fallback to alternative Jewish calendar sources if needed
-            - Manual city input for maximum accuracy and reliability
+            - **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("""