Upload 4 files

tools/currency_converter_tool.py

@@ -0,0 +1,91 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+import os
+import requests
+
+class ConvertCurrencyTool(Tool):
+    name = "convert_currency"
+    description = "Converts an amount between currencies for travel budgeting."
+    inputs = {
+        'amount': {'type': 'number', 'description': 'The amount to convert'},
+        'from_currency': {'type': 'string', 'description': 'Source currency code (e.g., USD, EUR)'},
+        'to_currency': {'type': 'string', 'description': 'Target currency code (e.g., JPY, GBP)'}
+    }
+    output_type = "string"
+
+    def __init__(self, api_key=None):
+        super().__init__()
+        # You can set an API key for a real currency API
+        self.api_key = api_key or os.environ.get("EXCHANGE_RATE_API_KEY")
+        
+        # Common exchange rates (as of early 2025, for demo/fallback purposes)
+        self.exchange_rates = {
+            "USD": {"EUR": 0.92, "GBP": 0.79, "JPY": 149.50, "CAD": 1.35, "AUD": 1.52, "CNY": 7.20, "INR": 83.20, "MXN": 17.05},
+            "EUR": {"USD": 1.09, "GBP": 0.86, "JPY": 163.00, "CAD": 1.47, "AUD": 1.66, "CNY": 7.85, "INR": 90.70, "MXN": 18.60},
+            "GBP": {"USD": 1.27, "EUR": 1.16, "JPY": 189.30, "CAD": 1.71, "AUD": 1.92, "CNY": 9.10, "INR": 105.30, "MXN": 21.60},
+            "JPY": {"USD": 0.0067, "EUR": 0.0061, "GBP": 0.0053, "CAD": 0.0090, "AUD": 0.0102, "CNY": 0.0482, "INR": 0.5565, "MXN": 0.1141},
+            "CAD": {"USD": 0.74, "EUR": 0.68, "GBP": 0.58, "JPY": 110.70, "AUD": 1.13, "CNY": 5.33, "INR": 61.60, "MXN": 12.60},
+            "AUD": {"USD": 0.66, "EUR": 0.60, "GBP": 0.52, "JPY": 98.40, "CAD": 0.89, "CNY": 4.73, "INR": 54.70, "MXN": 11.20},
+            "CNY": {"USD": 0.14, "EUR": 0.13, "GBP": 0.11, "JPY": 20.80, "CAD": 0.19, "AUD": 0.21, "INR": 11.60, "MXN": 2.37},
+            "INR": {"USD": 0.012, "EUR": 0.011, "GBP": 0.0095, "JPY": 1.80, "CAD": 0.016, "AUD": 0.018, "CNY": 0.086, "MXN": 0.205},
+            "MXN": {"USD": 0.059, "EUR": 0.054, "GBP": 0.046, "JPY": 8.77, "CAD": 0.079, "AUD": 0.089, "CNY": 0.422, "INR": 4.88}
+        }
+
+    def forward(self, amount: float, from_currency: str, to_currency: str) -> str:
+        try:
+            # Normalize currency codes
+            from_currency = from_currency.upper().strip()
+            to_currency = to_currency.upper().strip()
+            
+            # Try to use a real currency API if the API key is available
+            if self.api_key:
+                try:
+                    url = f"https://v6.exchangerate-api.com/v6/{self.api_key}/pair/{from_currency}/{to_currency}/{amount}"
+                    response = requests.get(url)
+                    data = response.json()
+                    
+                    if data.get('result') == 'success':
+                        converted_amount = data.get('conversion_result')
+                        rate = data.get('conversion_rate')
+                        
+                        return f"💱 {amount:,.2f} {from_currency} = {converted_amount:,.2f} {to_currency}\n\nExchange rate: 1 {from_currency} = {rate} {to_currency}\n\n(Data from ExchangeRate-API)"
+                    else:
+                        # Fall back to stored rates if API call fails
+                        return self._convert_with_stored_rates(amount, from_currency, to_currency)
+                
+                except Exception:
+                    # Fall back to stored rates if any error occurs
+                    return self._convert_with_stored_rates(amount, from_currency, to_currency)
+            
+            # If no API key is available, use the stored rates
+            return self._convert_with_stored_rates(amount, from_currency, to_currency)
+        
+        except Exception as e:
+            return f"Error converting currency: {str(e)}"
+    
+    def _convert_with_stored_rates(self, amount: float, from_currency: str, to_currency: str) -> str:
+        # Validate currencies
+        if from_currency not in self.exchange_rates:
+            return f"Sorry, I don't have exchange rate data for {from_currency}."
+        
+        # If same currency, return original amount
+        if from_currency == to_currency:
+            return f"{amount} {from_currency} = {amount} {to_currency}"
+        
+        # Direct conversion
+        if to_currency in self.exchange_rates[from_currency]:
+            rate = self.exchange_rates[from_currency][to_currency]
+            converted_amount = amount * rate
+            return f"💱 {amount:,.2f} {from_currency} = {converted_amount:,.2f} {to_currency}\n\nExchange rate: 1 {from_currency} = {rate} {to_currency}\n\n(Note: Rates are approximations for planning purposes only)"
+        
+        # Try conversion through USD
+        if to_currency in self.exchange_rates and "USD" in self.exchange_rates[from_currency]:
+            usd_amount = amount * self.exchange_rates[from_currency]["USD"]
+            rate_to_target = self.exchange_rates["USD"].get(to_currency)
+            
+            if rate_to_target:
+                converted_amount = usd_amount * rate_to_target
+                effective_rate = converted_amount / amount
+                return f"💱 {amount:,.2f} {from_currency} = {converted_amount:,.2f} {to_currency}\n\nExchange rate: 1 {from_currency} = {effective_rate:.4f} {to_currency}\n\n(Note: Rates are approximations for planning purposes only)"
+        
+        return f"Sorry, I don't have exchange rate data from {from_currency} to {to_currency}."

tools/local_time_tool.py

@@ -0,0 +1,112 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+import datetime
+import pytz
+
+class GetLocalTimeTool(Tool):
+    name = "get_local_time"
+    description = "Gets the current local time at a travel destination."
+    inputs = {'destination': {'type': 'string', 'description': 'A city or location name (e.g., "Paris", "Tokyo", "New York").'}}
+    output_type = "string"
+
+    def __init__(self):
+        super().__init__()
+        try:
+            import pytz
+        except ImportError as e:
+            raise ImportError(
+                "You must install package `pytz` to run this tool: for instance run `pip install pytz`."
+            ) from e
+        
+        # Map of common tourist destinations to their timezones
+        self.destination_timezones = {
+            "london": "Europe/London",
+            "paris": "Europe/Paris",
+            "rome": "Europe/Rome",
+            "madrid": "Europe/Madrid",
+            "berlin": "Europe/Berlin",
+            "amsterdam": "Europe/Amsterdam",
+            "athens": "Europe/Athens",
+            "istanbul": "Europe/Istanbul",
+            "dubai": "Asia/Dubai",
+            "new delhi": "Asia/Kolkata",
+            "mumbai": "Asia/Kolkata",
+            "bangkok": "Asia/Bangkok",
+            "singapore": "Asia/Singapore",
+            "tokyo": "Asia/Tokyo",
+            "seoul": "Asia/Seoul",
+            "beijing": "Asia/Shanghai",
+            "shanghai": "Asia/Shanghai",
+            "hong kong": "Asia/Hong_Kong",
+            "sydney": "Australia/Sydney",
+            "melbourne": "Australia/Melbourne",
+            "auckland": "Pacific/Auckland",
+            "fiji": "Pacific/Fiji",
+            "honolulu": "Pacific/Honolulu",
+            "anchorage": "America/Anchorage",
+            "los angeles": "America/Los_Angeles",
+            "san francisco": "America/Los_Angeles",
+            "las vegas": "America/Los_Angeles",
+            "denver": "America/Denver",
+            "chicago": "America/Chicago",
+            "houston": "America/Chicago",
+            "new york": "America/New_York",
+            "miami": "America/New_York",
+            "toronto": "America/Toronto",
+            "mexico city": "America/Mexico_City",
+            "rio de janeiro": "America/Sao_Paulo",
+            "sao paulo": "America/Sao_Paulo",
+            "buenos aires": "America/Argentina/Buenos_Aires",
+            "cairo": "Africa/Cairo",
+            "cape town": "Africa/Johannesburg",
+            "johannesburg": "Africa/Johannesburg",
+            "nairobi": "Africa/Nairobi"
+        }
+
+    def forward(self, destination: str) -> str:
+        try:
+            # Normalize the destination name
+            normalized_dest = destination.lower().strip()
+            
+            # Find the closest matching timezone
+            timezone = None
+            for city, tz in self.destination_timezones.items():
+                if city in normalized_dest or normalized_dest in city:
+                    timezone = tz
+                    break
+            
+            if not timezone:
+                # If we don't have a direct match, try to find it through pytz
+                try:
+                    # Try web search for timezone if available
+                    import importlib
+                    if importlib.util.find_spec("duckduckgo_search"):
+                        from duckduckgo_search import DDGS
+                        ddgs = DDGS()
+                        results = ddgs.text(f"{destination} timezone")
+                        if results:
+                            # Simple heuristic to extract timezone from search results
+                            for result in results:
+                                body = result.get('body', '').lower()
+                                if 'utc' in body or 'gmt' in body:
+                                    timezone_pos = body.find('utc') if 'utc' in body else body.find('gmt')
+                                    timezone_info = body[timezone_pos:timezone_pos+8]
+                                    return f"Based on web search, the timezone in {destination} appears to be around {timezone_info.upper()}. Current time information is not available."
+                except:
+                    pass
+                
+                return f"I don't have timezone information for {destination}. Please try a major city nearby."
+            
+            # Get current time in that timezone
+            tz = pytz.timezone(timezone)
+            local_time = datetime.datetime.now(tz)
+            
+            # Format the result
+            formatted_time = local_time.strftime("%I:%M %p on %A, %B %d, %Y")
+            time_diff = local_time.utcoffset().total_seconds() / 3600
+            sign = "+" if time_diff >= 0 else ""
+            
+            return f"The current local time in {destination} is {formatted_time} (UTC{sign}{int(time_diff)})"
+        
+        except Exception as e:
+            return f"Error getting local time for {destination}: {str(e)}"

tools/weather_forecast_tool.py

@@ -0,0 +1,168 @@
+from typing import Any, Optional
+from smolagents.tools import Tool
+import datetime
+import random
+import os
+import requests
+
+class GetWeatherForecastTool(Tool):
+    name = "get_weather_forecast"
+    description = "Gets the weather forecast for a travel destination."
+    inputs = {
+        'destination': {'type': 'string', 'description': 'City or location name'},
+        'days': {'type': 'integer', 'description': 'Number of days to forecast (default: 3)'}
+    }
+    output_type = "string"
+
+    def __init__(self, api_key=None):
+        super().__init__()
+        # You can set an API key for a real weather service like OpenWeatherMap
+        self.api_key = api_key or os.environ.get("WEATHER_API_KEY")
+        
+        # Weather conditions for demo/fallback
+        self.weather_conditions = [
+            "Sunny", "Partly Cloudy", "Cloudy", "Light Rain", 
+            "Heavy Rain", "Thunderstorms", "Windy", "Foggy", "Snow", "Clear"
+        ]
+
+    def forward(self, destination: str, days: int = 3) -> str:
+        try:
+            # Try to use a real weather API if the API key is available
+            if self.api_key:
+                try:
+                    url = f"http://api.openweathermap.org/data/2.5/forecast?q={destination}&appid={self.api_key}&units=metric"
+                    response = requests.get(url)
+                    data = response.json()
+                    
+                    if response.status_code != 200:
+                        # Fall back to demo method if API call fails
+                        return self._generate_demo_forecast(destination, days)
+                    
+                    # Process and format forecast data
+                    forecast_text = f"🌦️ Weather forecast for {destination}:\n\n"
+                    
+                    # Group forecasts by day
+                    forecasts_by_day = {}
+                    for item in data['list'][:days * 8]:  # API returns data in 3-hour intervals
+                        date = item['dt_txt'].split(' ')[0]
+                        if date not in forecasts_by_day:
+                            forecasts_by_day[date] = []
+                        forecasts_by_day[date].append(item)
+                    
+                    # Format each day's forecast
+                    for date, items in list(forecasts_by_day.items())[:days]:
+                        day_name = datetime.datetime.strptime(date, "%Y-%m-%d").strftime("%A")
+                        temps = [item['main']['temp'] for item in items]
+                        avg_temp = sum(temps) / len(temps)
+                        conditions = [item['weather'][0]['main'] for item in items]
+                        most_common = max(set(conditions), key=conditions.count)
+                        
+                        precipitation = any('Rain' in item['weather'][0]['main'] or 'Snow' in item['weather'][0]['main'] for item in items)
+                        precipitation_chance = "60%" if precipitation else "0%"
+                        
+                        forecast_text += f"• {day_name}, {date}: {most_common}, {min(temps):.1f}°C to {max(temps):.1f}°C"
+                        if precipitation:
+                            forecast_text += f", {precipitation_chance} chance of precipitation"
+                        forecast_text += "\n"
+                    
+                    # Add packing recommendations
+                    forecast_text += self._generate_packing_tips(forecasts_by_day)
+                    
+                    return forecast_text
+                
+                except Exception:
+                    # Fall back to demo method if any error occurs
+                    return self._generate_demo_forecast(destination, days)
+            
+            # If no API key is available, use the demo method
+            return self._generate_demo_forecast(destination, days)
+        
+        except Exception as e:
+            return f"Error retrieving weather data for {destination}: {str(e)}"
+    
+    def _generate_demo_forecast(self, destination: str, days: int) -> str:
+        # Create a deterministic but seemingly random forecast based on destination name
+        seed = sum(ord(c) for c in destination)
+        random.seed(seed)
+        
+        # Generate forecast data
+        forecast_text = f"🌦️ Weather forecast for {destination}:\n\n"
+        
+        today = datetime.datetime.now()
+        temp_base = random.randint(10, 25)  # Base temperature varies by destination
+        
+        for i in range(days):
+            day = today + datetime.timedelta(days=i)
+            day_name = day.strftime("%A")
+            date = day.strftime("%b %d")
+            
+            # "Random" but deterministic weather for the demo
+            condition = self.weather_conditions[random.randint(0, len(self.weather_conditions)-1)]
+            temp_high = temp_base + random.randint(0, 10)  # Celsius
+            temp_low = temp_high - random.randint(5, 15)
+            precipitation = random.randint(0, 100) if "Rain" in condition or "Snow" in condition or "Thunder" in condition else 0
+            
+            forecast_text += f"• {day_name}, {date}: {condition}, {temp_low}°C to {temp_high}°C"
+            if precipitation > 0:
+                forecast_text += f", {precipitation}% chance of precipitation"
+            forecast_text += "\n"
+        
+        # Add packing recommendations
+        cold_days = sum(1 for i in range(days) if temp_base + 5 < 15)
+        rainy_days = sum(1 for i in range(days) if "Rain" in self.weather_conditions[random.randint(0, len(self.weather_conditions)-1)])
+        hot_days = sum(1 for i in range(days) if temp_base + 5 > 25)
+        
+        forecast_text += "\n🧳 Packing tips: "
+        if cold_days > days/2:
+            forecast_text += "Bring warm layers and a jacket. "
+        elif cold_days > 0:
+            forecast_text += "Pack a light jacket for cooler periods. "
+        
+        if rainy_days > 0:
+            forecast_text += "Don't forget an umbrella or rain gear. "
+        
+        if hot_days > days/2:
+            forecast_text += "Bring sunscreen, sunglasses, and light clothing. "
+        
+        return forecast_text
+    
+    def _generate_packing_tips(self, forecasts_by_day):
+        # Extract temperature ranges across all days
+        all_temps = []
+        has_rain = False
+        has_snow = False
+        
+        for day_items in forecasts_by_day.values():
+            for item in day_items:
+                all_temps.append(item['main']['temp'])
+                if 'Rain' in item['weather'][0]['main']:
+                    has_rain = True
+                if 'Snow' in item['weather'][0]['main']:
+                    has_snow = True
+        
+        min_temp = min(all_temps) if all_temps else 0
+        max_temp = max(all_temps) if all_temps else 30
+        
+        # Generate packing tips based on conditions
+        tips = "\n🧳 Packing tips: "
+        
+        if min_temp < 5:
+            tips += "Bring a heavy winter coat, gloves, and hat. "
+        elif min_temp < 15:
+            tips += "Pack a warm jacket and layers. "
+        elif min_temp < 20:
+            tips += "Bring a light jacket for evenings. "
+        
+        if max_temp > 25:
+            tips += "Pack light, breathable clothing for warm days. "
+        
+        if has_rain:
+            tips += "Don't forget an umbrella and waterproof footwear. "
+        
+        if has_snow:
+            tips += "Bring waterproof boots and warm socks. "
+        
+        if max_temp > 22:
+            tips += "Sunscreen and sunglasses are recommended. "
+        
+        return tips