Update app.py

app.py

@@ -19,62 +19,193 @@ class ShabbatCandleLightingAgent:
         
     def get_user_location_simple(self) -> Optional[Dict[str, Any]]:
         """
-        Get user's approximate location using free IP geolocation services
+        Get user's approximate location using multiple IP geolocation services with improved accuracy
         """
         try:
-            # Try multiple free IP geolocation services
+            # Enhanced list of IP geolocation services with better accuracy
             services = [
-                "http://ip-api.com/json/",
-                "https://ipapi.co/json/",
-                "http://www.geoplugin.net/json.gp"
+                {
+                    "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"
+                }
             ]
             
-            for service_url in services:
+            location_results = []
+            
+            for service in services:
                 try:
-                    response = requests.get(service_url, timeout=5)
+                    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', '')}")
                         
-                        # Handle different API response formats
-                        if service_url.startswith("http://ip-api.com"):
-                            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')
-                                }
-                        elif service_url.startswith("https://ipapi.co"):
-                            if data.get('city'):
-                                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')
-                                }
-                        elif service_url.startswith("http://www.geoplugin.net"):
-                            if 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')
-                                }
                 except Exception as e:
-                    print(f"Service {service_url} failed: {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 _choose_best_location(self, locations: list) -> Dict[str, Any]:
+        """Choose the best location from multiple results using consensus and quality scoring"""
+        if len(locations) == 1:
+            return locations[0]
+        
+        # Score locations based on various factors
+        scored_locations = []
+        
+        for loc in locations:
+            score = 0
+            
+            # Accuracy scoring
+            accuracy_scores = {'high': 3, 'medium': 2, 'low': 1}
+            score += accuracy_scores.get(loc.get('accuracy', 'low'), 1)
+            
+            # Completeness scoring (more complete data = higher score)
+            if loc.get('city'): score += 2
+            if loc.get('country'): score += 1
+            if loc.get('region'): score += 1
+            if loc.get('lat') and loc.get('lng'): score += 2
+            if loc.get('timezone'): score += 1
+            
+            # Prefer certain sources
+            trusted_sources = ['ipapi.co', 'ip-api.com']
+            if loc.get('source') in trusted_sources:
+                score += 2
+            
+            scored_locations.append((score, loc))
+        
+        # Sort by score (highest first)
+        scored_locations.sort(key=lambda x: x[0], reverse=True)
+        
+        # Check for consensus among top results
+        top_cities = [loc[1]['city'] for loc in scored_locations[:3] if loc[1].get('city')]
+        
+        # If multiple services agree on the city, prefer that
+        if len(set(top_cities)) == 1:
+            best_location = scored_locations[0][1]
+        else:
+            # Take the highest scored location
+            best_location = scored_locations[0][1]
+        
+        # Add confidence level
+        if len(top_cities) >= 2 and len(set(top_cities)) == 1:
+            best_location['confidence'] = 'high'
+        elif len(top_cities) >= 2:
+            best_location['confidence'] = 'medium'
+        else:
+            best_location['confidence'] = 'low'
+        
+        return best_location
+    
     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
@@ -270,20 +401,30 @@ class ShabbatCandleLightingAgent:
         """
         try:
             city_name = city_input.strip()
+            location_info = ""
             
             # Auto-detect location if requested and no city provided
             if auto_detect and not city_name:
+                print("🔍 Attempting to detect your location...")
                 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']}"
+                    
+                    # Add location detection info
+                    confidence = location.get('confidence', 'unknown')
+                    source = location.get('source', 'unknown')
+                    location_info = f"\n**🌐 Auto-detected location:** {city_name} (confidence: {confidence}, source: {source})\n"
+                    
+                    if confidence == 'low':
+                        location_info += "⚠️ *Low confidence detection - please verify the city is correct*\n"
             
             if not city_name:
-                return self._format_error_response("❌ Please provide a city name or enable location detection.")
+                return self._format_error_response("❌ Не удалось определить ваше местоположение автоматически. Пожалуйста, введите название города вручную.")
             
             # 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
@@ -298,14 +439,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
@@ -313,9 +454,11 @@ 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}")
@@ -460,10 +603,17 @@ def create_shabbat_interface():
                 )
                 
                 gr.Markdown("""
-                ### 💡 **Tips:**
-                - Use full city names for better results
-                - Include country for common city names  
-                - Try nearest major city if yours isn't found
+                ### 💡 **Советы по вводу города:**
+                - Используйте полные названия городов для лучших результатов
+                - Добавляйте страну для распространенных названий (напри��ер, "Париж, Франция")
+                - Попробуйте ближайший крупный город, если ваш не найден
+                - **Автоопределение может быть неточным** - проверяйте результат
+                
+                ### 🌐 **Почему автоопределение может ошибаться:**
+                - IP-геолокация показывает местоположение интернет-провайдера
+                - VPN/прокси искажают реальное местоположение  
+                - Мобильные сети часто показывают центр обслуживания
+                - Точность: ±10-50 км от реального местоположения
                 """)
         
             with gr.Column(scale=2):