Update app.py

app.py

@@ -41,12 +41,15 @@ def get_current_time_in_timezone(timezone: str) -> str:
         return f"The current local time in {timezone} is: {local_time}"
     except Exception as e:
         return f"Error fetching time for timezone '{timezone}': {str(e)}"
-        
+
+
+
 @tool
 def get_horoscope(sign: str, date: str = None, language: str = "EN") -> str:
-    """Fetches the horoscope for a given zodiac sign and date.
+    """
+    Fetches the horoscope for a given zodiac sign and date.
     Uses the ExaWeb API. Defaults to today if no date is provided.
-    
+
     Args:
         sign: Zodiac sign (e.g., Aries, Taurus, Gemini)
         date: Date in any format (optional)
@@ -54,123 +57,139 @@ def get_horoscope(sign: str, date: str = None, language: str = "EN") -> str:
     """
     try:
         if date:
-            date_obj = parse_date(date)
+            date_obj = parser.parse(date)
         else:
             date_obj = datetime.datetime.now()
-
+        
         formatted_date = date_obj.strftime("%d-%m-%Y")
-
+        
         params = {
             "rashi": sign.upper(),
             "language": language,
-            "day": formatted_date  # Always include the formatted day
+            "day": formatted_date
         }
-
         url = "https://api.exaweb.in:3004/api/rashi"
+
         response = requests.get(url, params=params)
-        response.raise_for_status()
+        response.raise_for_status()  # Raise an exception for HTTP errors (4xx or 5xx)
+        
         data = response.json()
-
-        sign_upper = sign.upper()
-        sign_data = data.get(sign_upper)
+        sign_data = data.get(sign.upper())
 
         if sign_data:
-            return sign_data
-
-        return f"No horoscope found for sign: {sign}"
+            return json.dumps(sign_data) # Return the full data as a JSON string for the agent to parse
+        
+        return f"INFO: No horoscope found for sign: {sign}"
 
+    except requests.exceptions.RequestException as e:
+        return f"ERROR: [get_horoscope]: Network error while fetching horoscope: {e}"
+    except json.JSONDecodeError:
+        return f"ERROR: [get_horoscope]: Failed to parse a valid JSON response from the API."
     except Exception as e:
-        return f"Error fetching horoscope: {str(e)}"
+        return f"ERROR: [get_horoscope]: An unexpected error occurred: {str(e)}"
+
 
 
+
+
+
+        
 @tool
 def get_date_panchang(date: str = None, data_language: str = "EN") -> str:
-    """Fetches the Panchang data for a given date.
+    """
+    Fetches the Panchang data for a given date.
     If the user does not provide a date, use today's real date.
+
     Args:
-        date: Date in any format (optional)
+        date: Date in any format (optional).
         data_language: Language of the Panchang data (e.g., 'EN' for English, 'HI' for Hindi).
     """
 
-
-    if not date:
-        now = datetime.datetime.now()
-    else:
-        try:
-            now = datetime.datetime.strptime(date, "%Y-%m-%d")
-        except ValueError:
-            return " Invalid date format. Use YYYY-MM-DD."
-
-    api_date = now.strftime("%d/%m/%y")  # Format as DD/MM/YY for API
-
     try:
+        if not date:
+            now = datetime.datetime.now()
+        else:
+            now = parser.parse(date)
+        
+        api_date = now.strftime("%d/%m/%y")
+        
         url = (
             f"https://api.exaweb.in:3004/api/panchang/daily?"
             f"date={api_date}&app_language=EN&data_language={data_language}"
         )
-
-        headers = {
-            "api_key": "anvl_bharat_cal123", 
-            "Content-Type": "application/json"
-        }
-
+        headers = { "api_key": "anvl_bharat_cal123", 
+                    "Content-Type": "application/json" }
+        
         response = requests.get(url, headers=headers)
         response.raise_for_status()
+        
         data = response.json()
 
-        if not data or not isinstance(data, dict):
-            return "Empty or unexpected response."
+
+        if not isinstance(data, dict) or not data:
+            return "ERROR: [get_date_panchang]: Received empty or invalid data from API."
 
         summary = {
             "date": data.get("date", "N/A"),
             "location": data.get("location", "N/A"),
-            "Sunrise": data.get("Sunrise") if isinstance(data.get("Sunrise"), list) else [],
-            "Sunset": data.get("Sunset") if isinstance(data.get("Sunset"), list) else [],
-            "Tithi": data.get("Tithi") if isinstance(data.get("Tithi"), list) else [],
-            "Nakshatra": data.get("Nakshatra") if isinstance(data.get("Nakshatra"), list) else [],
-            "Yoga": data.get("Yoga") if isinstance(data.get("Yoga"), list) else [],
-            "Karana": data.get("Karana") if isinstance(data.get("Karana"), list) else [],
-            "Festivals": data.get("festivals") if isinstance(data.get("festivals"), list) else [],
+            "Sunrise": data.get("Sunrise", []),
+            "Sunset": data.get("Sunset", []),
+            "Tithi": data.get("Tithi", []),
+            "Nakshatra": data.get("Nakshatra", []),
+            "Yoga": data.get("Yoga", []),
+            "Karana": data.get("Karana", []),
+            "Festivals": data.get("festivals", []),
         }
+        
+
+        sunrise_str = ', '.join(map(str, summary['Sunrise'])) or 'N/A'
+        sunset_str = ', '.join(map(str, summary['Sunset'])) or 'N/A'
+        tithi_str = ', '.join(map(str, summary['Tithi'])) or 'N/A'
+        nakshatra_str = ', '.join(map(str, summary['Nakshatra'])) or 'N/A'
+        yoga_str = ', '.join(map(str, summary['Yoga'])) or 'N/A'
+        karana_str = ', '.join(map(str, summary['Karana'])) or 'N/A'
+        festivals_str = ', '.join(f for f in map(str, summary['Festivals']) if f.strip().upper() != 'NA') or 'None'
+
         return (
             f"Panchang for {summary['date']} in {summary['location']}:\n"
-            f"🌅 Sunrise: {', '.join(summary['Sunrise'] or ['N/A'])}\n"
-            f"🌇 Sunset: {', '.join(summary['Sunset'] or ['N/A'])}\n"
-            f"📜 Tithi: {', '.join(summary['Tithi'] or ['N/A'])}\n"
-            f"✨ Nakshatra: {', '.join(summary['Nakshatra'] or ['N/A'])}\n"
-            f"🧘 Yoga: {', '.join(summary['Yoga'] or ['N/A'])}\n"
-            f"🔺 Karana: {', '.join(summary['Karana'] or ['N/A'])}\n"
-            f"🎉 Festivals: {', '.join(summary['Festivals'] or ['None'])}"
-
+            f"🌅 Sunrise: {sunrise_str}\n"
+            f"🌇 Sunset: {sunset_str}\n"
+            f"📜 Tithi: {tithi_str}\n"
+            f"✨ Nakshatra: {nakshatra_str}\n"
+            f"🧘 Yoga: {yoga_str}\n"
+            f"🔺 Karana: {karana_str}\n"
+            f"🎉 Festivals: {festivals_str}"
         )
 
+    except requests.exceptions.RequestException as e:
+        return f"ERROR: [get_date_panchang]: Network error while fetching Panchang: {e}"
+    except json.JSONDecodeError:
+        return f"ERROR: [get_date_panchang]: Failed to parse a valid JSON response from the API."
+    except Exception as e:
+        return f"ERROR: [get_date_panchang]: An unexpected error occurred: {str(e)}"
+
+
 
 
 
-    except Exception as e:
-        return f" Failed to fetch Panchang for {api_date}: {str(e)}"
-        
 
 @tool
-def get_holidays(year: int = None, app_language: str = "EN", data_language: str = "HI") -> str:
+def get_holidays(year: int = None, app_language: str = "EN", data_language: str = "EN") -> str:
     """
-    Fetches holidays from all categories (Hindu, Islamic, Christian) for a given year from ExaWeb API.
+    Fetches holidays from all categories for a given year from ExaWeb API.
+
     Args:
         year: Year (e.g., 2025). Optional — defaults to current year.
         app_language: App language for API (default: "EN").
         data_language: Data language for holidays (default: "HI").
     """
+
     if not year:
         year = datetime.datetime.now().year
-
-    params = {
-        "app_language": app_language,
-        "data_language": data_language,
-        "year": year
-    }
-    headers = {
-        "api_key": "anvl_bharat_cal123"
-    }
+        
+    params = { "app_language": app_language, "data_language": data_language, "year": year }
+    headers = { "api_key": "anvl_bharat_cal123", 
+                "Content-Type": "application/json" }
 
     try:
         response = requests.get(
@@ -181,101 +200,97 @@ def get_holidays(year: int = None, app_language: str = "EN", data_language: str
         response.raise_for_status()
         data = response.json()
 
-        formatted = []
+        if not isinstance(data, dict):
+            return f"INFO: No holiday data found for {year}."
 
+        formatted = []
+        # --- ROBUSTNESS: Process only keys whose values are lists (safer than a blocklist) ---
         for category, groups in data.items():
-            if category in ["year", "app_language", "data_language"]:
-                continue  # Skip non-holiday keys
-
-            formatted.append(f"\n=== {category} Holidays ===")
-
-            for group in groups:
-                for holiday in group:
-                    title = holiday.get("title", "")
-                    date = holiday.get("date", "")
-                    formatted.append(f"{date}: {title}")
-
-        return "\n".join(formatted) if formatted else f"No holidays found for {year}."
-
-    except requests.RequestException as e:
-        return f"Error fetching holidays: {e}"
+            if isinstance(groups, list):
+                formatted.append(f"\n=== {category.replace('_', ' ').title()} ===")
+                for group in groups:
+                    # The API structure has a nested list, ensure group is a list
+                    if isinstance(group, list):
+                        for holiday in group:
+                             if isinstance(holiday, dict):
+                                title = holiday.get("title", "N/A")
+                                date = holiday.get("date", "N/A")
+                                formatted.append(f"{date}: {title}")
+        
+        return "\n".join(formatted) if formatted else f"INFO: No holidays found for {year}."
 
+    except requests.exceptions.RequestException as e:
+        return f"ERROR: [get_holidays]: Network error fetching holidays: {e}"
+    except json.JSONDecodeError:
+        return f"ERROR: [get_holidays]: Failed to parse a valid JSON response from the API."
+    except Exception as e:
+        return f"ERROR: [get_holidays]: An unexpected error occurred: {str(e)}"
 
 @tool
-def get_monthly_festivals(year: Optional[int] = None,month: Optional[str] = None,app_language: str = "EN",data_language: str = "EN") -> str:
+def get_monthly_festivals(year: Optional[int] = None, month: Optional[str] = None, app_language: str = "EN", data_language: str = "EN") -> str:
     """
     Fetches festival data for a specific month and year from the ExaWeb API.
+    
     Args:
-        year: The year for which to fetch the festivals (e.g., 2025).
-              If not provided, the current year will be used.
-        month: The full name of the month for which to fetch the festivals (e.g., "june").
-               If not provided, the current month will be used.
+        year: The year to fetch (e.g., 2025). Defaults to current year.
+        month: The full month name to fetch (e.g., "june"). Defaults to current month.
         app_language: The language for the application interface (default: "EN").
         data_language: The language for the festival names (default: "EN").
-    Returns:
-        A formatted string listing the festivals for the given month and year,
-        or an error message if the data cannot be fetched.
     """
-    # Set default year to the current year if not provided
+    api_key = os.environ.get("EXAWEB_API_KEY")
+    if not api_key:
+        return "ERROR: [get_monthly_festivals]: API key is not configured."
+    
     if not year:
         year = datetime.datetime.now().year
-
-    # Set default month to the current month if not provided
     if not month:
         month = datetime.datetime.now().strftime("%B").lower()
     else:
         month = month.lower()
 
-    # API endpoint and parameters
     api_url = "https://api.exaweb.in:3004/api/panchang/festival"
-    params = {
-        "year": year,
-        "month": month,
-        "app_language": app_language,
-        "data_language": data_language,
-    }
-    headers = {
-        "api_key": "anvl_bharat_cal123", 
-        "Content-Type": "application/json"
-    }
+    params = { "year": year, "month": month, "app_language": app_language, "data_language": data_language }
+    headers = { "api_key": "anvl_bharat_cal123", 
+                 "Content-Type": "application/json" }
 
     try:
-        # Make the GET request to the API
         response = requests.get(api_url, params=params, headers=headers)
-        # Raise an exception for bad status codes (4xx or 5xx)
         response.raise_for_status()
-        
-        # Parse the JSON response
         data = response.json()
 
         if not data:
-            return f"No festival data found for {month.capitalize()} {year}."
-
-        # Format the data for display
+            return f"INFO: No festival data found for {month.capitalize()} {year}."
+        
         formatted_lines = []
         for entry in data:
-            date = entry.get("date", "Unknown date")
-            festivals = entry.get("festivals", [])
-            
-            # Filter out entries where the only festival is "NA"
-            meaningful_festivals = [f for f in festivals if f.strip().upper() != "NA"]
-            
-            if meaningful_festivals:
-                # Join multiple festivals with a comma
-                festivals_str = ", ".join(meaningful_festivals)
-                formatted_lines.append(f"{date}: {festivals_str}")
+            if isinstance(entry, dict):
+                date = entry.get("date", "Unknown date")
+                festivals = entry.get("festivals", [])
+                
+                meaningful_festivals = [f for f in festivals if isinstance(f, str) and f.strip().upper() != "NA"]
+                
+                if meaningful_festivals:
+                    festivals_str = ", ".join(meaningful_festivals)
+                    formatted_lines.append(f"{date}: {festivals_str}")
 
         if not formatted_lines:
-            return f"No festivals found for {month.capitalize()} {year}."
-
+            return f"INFO: No festivals found for {month.capitalize()} {year}."
+        
         return "\n".join(formatted_lines)
 
     except requests.exceptions.RequestException as e:
-        # Handle connection errors, timeouts, etc.
-        return f"An error occurred while fetching data from the API: {e}"
-    except ValueError:
-        # Handle cases where the response is not valid JSON
-        return "Failed to decode the response from the API."
+        return f"ERROR: [get_monthly_festivals]: Network error while fetching data: {e}"
+    except json.JSONDecodeError:
+        return f"ERROR: [get_monthly_festivals]: Failed to parse a valid JSON response from the API."
+    except Exception as e:
+        return f"ERROR: [get_monthly_festivals]: An unexpected error occurred: {str(e)}"
+
+
+
+
+
+
+         
 
 final_answer = FinalAnswerTool()