Weather Tools

def fetch_current_weather_conditions(
    self, location: str, language: str = "en"
) -> str:
    """
    Get current weather conditions for a location.

    Args:
        location: Location name or coordinates
        language: Language code (default: en)

    Returns:
        JSON string containing current weather data

    Raises:
        WeatherError: If weather data retrieval fails
    """
    try:
        # Validate inputs
        self._validate_location(location)
        lang = self._validate_language(language)

        log_debug(f"Getting current weather for {location} in {language}")

        wttr_kwargs = self._build_wttr_kwargs()

        # Get weather data
        assert Wttr is not None
        with Wttr(**wttr_kwargs) as wttr:
            weather_data = wttr.weather(location, language=lang)

        # Extract current weather
        if (
            not weather_data
            or not hasattr(weather_data, "weather")
            or not weather_data.weather
        ):
            raise WeatherError(
                "No weather data available for this location"
            )

        current = weather_data.weather[0]

        # Format response
        result = {
            "operation": "current_weather",
            "location": location,
            "timestamp": datetime.now().isoformat(),
            "current_condition": {
                "temp_c": getattr(current, "avgtemp_c", None),
                "temp_f": getattr(current, "avgtemp_f", None),
                "feels_like_c": getattr(current, "feelslike_c", None),
                "feels_like_f": getattr(current, "feelslike_f", None),
                "humidity": getattr(current, "humidity", None),
                "weather_desc": self._get_weather_desc(current),
                "wind_speed_kmph": getattr(current, "maxwind_kph", None),
                "wind_speed_mph": getattr(current, "maxwind_mph", None),
                "precipitation_mm": getattr(
                    current, "totalprecip_mm", None
                ),
                "precipitation_in": getattr(
                    current, "totalprecip_in", None
                ),
                "uv_index": getattr(current, "uv", None),
            },
            "metadata": {
                "language": language,
                "source": "wttr.in",
            },
        }

        log_info(f"Retrieved current weather for {location}")
        return json.dumps(result, indent=2, ensure_ascii=False)

    except WeatherError:
        raise
    except Exception as e:
        log_error(f"Error getting current weather: {e}")
        raise WeatherError(f"Failed to get current weather: {e}") from e

def fetch_weather_forecast(
    self, location: str, days: int = 3, language: str = "en"
) -> str:
    """
    Get weather forecast for a location.

    Args:
        location: Location name or coordinates
        days: Number of days for forecast (1-7)
        language: Language code (default: en)

    Returns:
        JSON string containing weather forecast

    Raises:
        WeatherError: If weather data retrieval fails
    """
    try:
        # Validate inputs
        self._validate_location(location)
        lang = self._validate_language(language)
        days = max(1, min(7, days))  # Limit between 1-7 days

        log_debug(
            f"Getting {days}-day forecast for {location} in {language}"
        )

        wttr_kwargs = self._build_wttr_kwargs()

        # Get weather data
        assert Wttr is not None
        with Wttr(**wttr_kwargs) as wttr:
            weather_data = wttr.weather(location, language=lang)

        # Extract forecast
        if (
            not weather_data
            or not hasattr(weather_data, "weather")
            or not weather_data.weather
        ):
            raise WeatherError(
                "No weather data available for this location"
            )

        forecast_days = weather_data.weather[:days]

        # Format response
        forecast = []
        for day in forecast_days:
            forecast.append(
                {
                    "date": getattr(day, "date", None),
                    "max_temp_c": getattr(day, "maxtemp_c", None),
                    "max_temp_f": getattr(day, "maxtemp_f", None),
                    "min_temp_c": getattr(day, "mintemp_c", None),
                    "min_temp_f": getattr(day, "mintemp_f", None),
                    "avg_temp_c": getattr(day, "avgtemp_c", None),
                    "avg_temp_f": getattr(day, "avgtemp_f", None),
                    "weather_desc": self._get_weather_desc(day),
                    "max_wind_kph": getattr(day, "maxwind_kph", None),
                    "max_wind_mph": getattr(day, "maxwind_mph", None),
                    "total_precip_mm": getattr(
                        day, "totalprecip_mm", None
                    ),
                    "total_precip_in": getattr(
                        day, "totalprecip_in", None
                    ),
                    "chance_of_rain": getattr(
                        day, "daily_chance_of_rain", None
                    ),
                    "uv_index": getattr(day, "uv", None),
                }
            )

        result = {
            "operation": "weather_forecast",
            "location": location,
            "timestamp": datetime.now().isoformat(),
            "forecast_days": days,
            "forecast": forecast,
            "metadata": {
                "language": language,
                "source": "wttr.in",
            },
        }

        log_info(f"Retrieved {days}-day forecast for {location}")
        return json.dumps(result, indent=2, ensure_ascii=False)

    except WeatherError:
        raise
    except Exception as e:
        log_error(f"Error getting weather forecast: {e}")
        raise WeatherError(f"Failed to get weather forecast: {e}") from e

def fetch_temperature_data(
    self, location: str, language: str = "en"
) -> str:
    """
    Get temperature data for a location.

    Args:
        location: Location name or coordinates
        language: Language code (default: en)

    Returns:
        JSON string containing temperature data

    Raises:
        WeatherError: If weather data retrieval fails
    """
    try:
        # Validate inputs
        self._validate_location(location)
        lang = self._validate_language(language)

        log_debug(f"Getting temperature for {location} in {language}")

        wttr_kwargs = self._build_wttr_kwargs()

        # Get weather data
        assert Wttr is not None
        with Wttr(**wttr_kwargs) as wttr:
            weather_data = wttr.weather(location, language=lang)

        # Extract temperature data
        if (
            not weather_data
            or not hasattr(weather_data, "weather")
            or not weather_data.weather
        ):
            raise WeatherError(
                "No weather data available for this location"
            )

        current = weather_data.weather[0]

        # Format response
        result = {
            "operation": "temperature",
            "location": location,
            "timestamp": datetime.now().isoformat(),
            "temperature": {
                "current_c": getattr(current, "avgtemp_c", None),
                "current_f": getattr(current, "avgtemp_f", None),
                "feels_like_c": getattr(current, "feelslike_c", None),
                "feels_like_f": getattr(current, "feelslike_f", None),
                "max_c": getattr(current, "maxtemp_c", None),
                "max_f": getattr(current, "maxtemp_f", None),
                "min_c": getattr(current, "mintemp_c", None),
                "min_f": getattr(current, "mintemp_f", None),
            },
            "metadata": {
                "language": language,
                "source": "wttr.in",
            },
        }

        log_info(f"Retrieved temperature data for {location}")
        return json.dumps(result, indent=2, ensure_ascii=False)

    except WeatherError:
        raise
    except Exception as e:
        log_error(f"Error getting temperature data: {e}")
        raise WeatherError(f"Failed to get temperature data: {e}") from e

def fetch_weather_text_description(
    self, location: str, language: str = "en"
) -> str:
    """
    Get weather description for a location.

    Args:
        location: Location name or coordinates
        language: Language code (default: en)

    Returns:
        JSON string containing weather description

    Raises:
        WeatherError: If weather data retrieval fails
    """
    try:
        # Validate inputs
        self._validate_location(location)
        lang = self._validate_language(language)

        log_debug(
            f"Getting weather description for {location} in {language}"
        )

        wttr_kwargs = self._build_wttr_kwargs()

        # Get weather data
        assert Wttr is not None
        with Wttr(**wttr_kwargs) as wttr:
            weather_data = wttr.weather(location, language=lang)

        # Extract weather description
        if (
            not weather_data
            or not hasattr(weather_data, "weather")
            or not weather_data.weather
        ):
            raise WeatherError(
                "No weather data available for this location"
            )

        current = weather_data.weather[0]
        weather_desc = self._get_weather_desc(current)

        # Format response
        result = {
            "operation": "weather_description",
            "location": location,
            "timestamp": datetime.now().isoformat(),
            "description": weather_desc,
            "metadata": {
                "language": language,
                "source": "wttr.in",
            },
        }

        log_info(f"Retrieved weather description for {location}")
        return json.dumps(result, indent=2, ensure_ascii=False)

    except WeatherError:
        raise
    except Exception as e:
        log_error(f"Error getting weather description: {e}")
        raise WeatherError(
            f"Failed to get weather description: {e}"
        ) from e

    @staticmethod
    def get_llm_usage_instructions() -> str:
        """Return short, text-first usage instructions for the weather tools."""
        return """
<weather_tools>
Weather lookup via wttr.in (pywttr)

GOAL
- Weather lookup via wttr.in (pywttr). All tools return JSON strings.

TOOLS
- fetch_current_weather_conditions(location, language='en')
- fetch_weather_forecast(location, days=3, language='en')  # days clamped 1..7
- fetch_temperature_data(location, language='en')
- fetch_weather_text_description(location, language='en')

CONTEXT-SIZE RULES (IMPORTANT)
- Prefer days<=3 unless the user explicitly asks for a longer forecast.
- Do not paste the full JSON into the final answer; summarize key fields.

NOTES
- location: city name or "lat,lon".
- language: falls back to English if unsupported.
</weather_tools>
"""