Update app.py

app.py

@@ -17,189 +17,7 @@ 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 get_user_location_simple(self) -> Optional[Dict[str, Any]]:
-        """
-        Get user's approximate location using multiple IP geolocation services with improved accuracy
-        """
-        try:
-            # Enhanced list of IP geolocation services with better accuracy
-            services = [
-                {
-                    "url": "http://ip-api.com/json/?fields=status,message,country,countryCode,region,regionName,city,zip,lat,lon,timezone,isp",
-                    "parser": "ip_api"
-                },
-                {
-                    "url": "https://ipapi.co/json/",
-                    "parser": "ipapi_co"
-                },
-                {
-                    "url": "https://freegeoip.app/json/",
-                    "parser": "freegeoip"
-                },
-                {
-                    "url": "http://www.geoplugin.net/json.gp",
-                    "parser": "geoplugin"
-                },
-                {
-                    "url": "https://ipgeolocation.abstractapi.com/v1/?api_key=free",
-                    "parser": "abstractapi"
-                }
-            ]
-            
-            location_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_location_data(data, service["parser"])
-                        
-                        if parsed_location and parsed_location.get('city'):
-                            location_results.append(parsed_location)
-                            print(f"✅ {service['parser']}: {parsed_location['city']}, {parsed_location.get('country', '')}")
-                        
-                except Exception as e:
-                    print(f"❌ Service {service['parser']} failed: {e}")
-                    continue
-            
-            # Choose the best result based on consensus or quality
-            if location_results:
-                best_location = self._choose_best_location(location_results)
-                print(f"🎯 Selected location: {best_location['city']}, {best_location.get('country', '')}")
-                return best_location
-                
-        except Exception as e:
-            print(f"Location detection error: {e}")
-        
-        return None
-    
-    def _parse_location_data(self, data: dict, parser_type: str) -> Optional[Dict[str, Any]]:
-        """Parse location data from different API response formats"""
-        try:
-            if 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'),
-                        'source': 'ip-api.com',
-                        'accuracy': 'medium'
-                    }
-            
-            elif 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'),
-                        'source': 'ipapi.co',
-                        'accuracy': 'high'
-                    }
-            
-            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'),
-                        'source': 'freegeoip.app',
-                        'accuracy': 'medium'
-                    }
-            
-            elif parser_type == "geoplugin":
-                if data.get('geoplugin_city') and data.get('geoplugin_city') != '':
-                    return {
-                        'city': data.get('geoplugin_city'),
-                        'country': data.get('geoplugin_countryName'),
-                        'region': data.get('geoplugin_region'),
-                        'lat': data.get('geoplugin_latitude'),
-                        'lng': data.get('geoplugin_longitude'),
-                        'timezone': data.get('geoplugin_timezone'),
-                        'source': 'geoplugin.net',
-                        'accuracy': 'low'
-                    }
-            
-            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'),
-                        'source': 'abstractapi.com',
-                        'accuracy': 'high'
-                    }
-                    
-        except Exception as e:
-            print(f"Parse error for {parser_type}: {e}")
-        
-        return None
-    
-    def _is_likely_datacenter_location(self, city: str, country: str) -> bool:
-        """
-        Check if the detected location is likely a data center rather than user's real location
-        """
-        datacenter_locations = [
-            # Major US data centers
-            ("ashburn", "united states"), ("ashburn", "usa"), ("ashburn", "us"),
-            ("reston", "united states"), ("reston", "usa"), ("reston", "us"),
-            ("santa clara", "united states"), ("santa clara", "usa"),
-            ("fremont", "united states"), ("fremont", "usa"),
-            ("dallas", "united states"), ("dallas", "usa"),
-            # European data centers
-            ("amsterdam", "netherlands"), ("amsterdam", "holland"),
-            ("frankfurt", "germany"), ("dublin", "ireland"),
-            # Asian data centers
-            ("singapore", "singapore"), ("tokyo", "japan"),
-            ("hong kong", "hong kong"), ("seoul", "south korea")
-        ]
-        
-        city_lower = city.lower() if city else ""
-        country_lower = country.lower() if country else ""
-        
-        return (city_lower, country_lower) in datacenter_locations
-    
-    def _suggest_likely_countries(self, detected_datacenter: str) -> list:
-        """
-        Suggest likely countries based on common data center routing patterns
-        """
-        suggestions = {
-            "ashburn": ["Israel", "Turkey", "Eastern Europe", "Middle East"],
-            "amsterdam": ["Eastern Europe", "Scandinavia", "Russia"],
-            "singapore": ["Australia", "Southeast Asia", "India"],
-            "tokyo": ["Asia-Pacific", "Australia", "Philippines"],
-            "frankfurt": ["Europe", "Middle East", "Africa"]
-        }
-        
-        datacenter = detected_datacenter.lower()
-        for dc in suggestions:
-            if dc in datacenter:
-                return suggestions[dc]
-        
-        return best_location
-    
-    def _choose_best_location(self, locations: list) -> Dict[str, Any]:
 
-    
     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
@@ -389,18 +207,26 @@ class ShabbatCandleLightingAgent:
         
         return None
     
-    def get_shabbat_times(self, city_input: str = "") -> str:
+    def get_shabbat_times(self, city_input: str = "", auto_detect: bool = True) -> str:
         """
         Main function to get Shabbat candle lighting times
         """
         try:
             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_simple()
+                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']}"
+            
             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 provide a city name or enable location detection.")
             
             # Search Chabad.org for the city
-            print(f"🔍 Searching for Shabbat times in: {city_name}")
+            print(f"Searching for Shabbat times in: {city_name}")
             city_url = self.search_city_on_chabad(city_name)
             
             result_data = None
@@ -415,14 +241,14 @@ class ShabbatCandleLightingAgent:
                     
                     if response.status_code == 200:
                         result_data = self.extract_candle_lighting_times(response.text, city_name)
-                        print(f"📊 Extraction result: {result_data}")
+                        print(f"Extraction result: {result_data}")
                         
                 except Exception as e:
-                    print(f"❌ Chabad.org fetch error: {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...")
+                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
@@ -437,7 +263,6 @@ class ShabbatCandleLightingAgent:
         except Exception as e:
             print(f"Main function error: {e}")
             return self._format_error_response(f"❌ An error occurred: {str(e)}")
-
     
     def _format_success_response(self, data: Dict[str, Any], source: str, url: str = None) -> str:
         """Format successful response with Shabbat times"""
@@ -470,44 +295,9 @@ class ShabbatCandleLightingAgent:
 **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
 
 ---
 
@@ -561,10 +351,16 @@ 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="Leave empty to auto-detect your location",
                     lines=1
                 )
                 
+                auto_detect = gr.Checkbox(
+                    label="🌐 Auto-detect my location",
+                    value=True,
+                    info="Automatically find your location if no city is entered"
+                )
+                
                 search_btn = gr.Button(
                     "🔍 Get Shabbat Times",
                     variant="primary",
@@ -572,18 +368,10 @@ def create_shabbat_interface():
                 )
                 
                 gr.Markdown("""
-                ### 💡 **City Input Tips:**
+                ### 💡 **Tips:**
                 - Use full city names for better results
-                - Add country for common city names (e.g., "Paris, France")
+                - Include country for common city names  
                 - Try nearest major city if yours isn't found
-                - Use English city names for best search results
-                
-                ### 🇮🇱 **Popular Israeli Cities:**
-                Jerusalem, Tel Aviv, Haifa, Beer Sheva, Netanya, Ashdod, 
-                Petah Tikva, Ramat Gan, Bnei Brak, Herzliya
-                
-                ### 🌍 **International Examples:**
-                London, UK • Paris, France • New York, USA • Toronto, Canada
                 """)
         
             with gr.Column(scale=2):
@@ -592,15 +380,9 @@ def create_shabbat_interface():
                     value="""
 # 🕯️ Welcome!
 
-���� **Enter your city name above and click 'Get Shabbat Times'**
+👆 **Enter a city name and click 'Get Shabbat Times' to begin**
 
-Or click one of the popular cities below for a quick search.
-
-### 🇮🇱 **Common Israeli Cities:**
-Use any of these city names: Jerusalem, Tel Aviv, Haifa, Beer Sheva, Netanya, Ashdod
-
-### 🌍 **International Cities:**  
-Include country name: London, UK • Paris, France • New York, USA
+Or try one of the popular cities below for a quick search.
 
 ---
 
@@ -613,20 +395,14 @@ Include country name: London, UK • Paris, France • New York, USA
         
         with gr.Row():
             popular_cities = [
-                # Israeli cities first for the detected user
-                "Jerusalem, Israel",
-                "Tel Aviv, Israel", 
-                "Haifa, Israel",
-                "Beer Sheva, Israel",
-                "Netanya, Israel",
-                "Ashdod, Israel",
-                # International cities
                 "New York, NY",
+                "Los Angeles, CA", 
                 "London, UK",
-                "Paris, France",
-                "Toronto, Canada",
-                "Los Angeles, CA",
-                "Miami, FL"
+                "Jerusalem, Israel",
+                "Tel Aviv, Israel",
+                "Miami, FL",
+                "Chicago, IL",
+                "Toronto, Canada"
             ]
             
             example_btns = []
@@ -639,14 +415,14 @@ Include country name: London, UK • Paris, France • New York, USA
         # Button click handlers
         search_btn.click(
             fn=agent.get_shabbat_times,
-            inputs=[city_input],
+            inputs=[city_input, auto_detect],
             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
             )
         
@@ -679,10 +455,10 @@ 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
+            - Auto-location detection using IP geolocation
+            - Multiple search strategies for maximum success
+            - Intelligent pattern matching to extract times
+            - Fallback to alternative Jewish calendar sources
             """)
         
         gr.Markdown("""