Spaces:
Sleeping
Sleeping
| 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 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: | |
| # 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 = "") -> str: | |
| """ | |
| Main function to get Shabbat candle lighting times | |
| """ | |
| try: | |
| city_name = city_input.strip() | |
| if not city_name: | |
| return self._format_error_response("❌ Please enter a city name 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'): | |
| return self._format_success_response(result_data, source, city_url) | |
| else: | |
| return self._format_not_found_response(city_name, city_url) | |
| 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""" | |
| 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="Please enter your city name to get accurate Shabbat times", | |
| lines=1 | |
| ) | |
| search_btn = gr.Button( | |
| "🔍 Get Shabbat Times", | |
| variant="primary", | |
| size="lg" | |
| ) | |
| 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 | |
| """) | |
| with gr.Column(scale=2): | |
| output_area = gr.Markdown( | |
| label="📋 Shabbat Times Results", | |
| value=""" | |
| # 🕯️ Welcome! | |
| 👆 **Enter your city name above and click 'Get Shabbat Times'** | |
| --- | |
| **🕯️ Every Friday evening, Jewish families around the world light candles to welcome Shabbat** | |
| """ | |
| ) | |
| # Button click handlers | |
| search_btn.click( | |
| fn=agent.get_shabbat_times, | |
| inputs=[city_input], | |
| 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:** | |
| - 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 | |
| """) | |
| 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 | |
| ) |