Working with APIs and External Services

#!/usr/bin/env python3
import os
import sys
import requests
from typing import Optional, Tuple

from fastapi import FastAPI, HTTPException

app = FastAPI(title="Weather API", description="Get weather information for cities")


def get_coordinates(city_name: str) -> Optional[Tuple[float, float]]:
    """
    Get latitude and longitude for a city using the Nominatim API.
    Returns (lat, lon) as floats or None if not found / on error.
    """
    url = "https://nominatim.openstreetmap.org/search"
    params = {
        "q": city_name,
        "format": "json",
        "limit": 1,
    }
    headers = {"User-Agent": "WeatherScript/1.0"}

    try:
        response = requests.get(url, params=params, headers=headers, timeout=10)
        response.raise_for_status()
        data = response.json()
        if data:
            lat = float(data[0]["lat"])
            lon = float(data[0]["lon"])
            return lat, lon
        else:
            return None
    except requests.RequestException as e:
        print(f"Error fetching coordinates: {e}")
        return None


def get_weather(lat: float, lon: float, api_key: str, debug: bool = False) -> Optional[dict]:
    """
    Get current weather from OpenWeather using latitude and longitude.
    Uses metric units (Celsius) and returns the parsed JSON or None on error.
    """
    url = "https://api.openweathermap.org/data/2.5/weather"
    params = {
        "lat": lat,
        "lon": lon,
        "appid": api_key,
        "units": "metric",
    }

    if debug:
        short_key = api_key[:8] + "..." if api_key else "(no key)"
        print(f"Debug: Making request to {url}")
        print(f"Debug: Parameters: lat={lat}, lon={lon}, appid={short_key}")

    try:
        response = requests.get(url, params=params, timeout=10)
        if debug:
            print(f"Debug: Response status: {response.status_code}")
            if response.status_code != 200:
                print(f"Debug: Response text: {response.text}")
        response.raise_for_status()
        return response.json()
    except requests.RequestException as e:
        print(f"Error fetching weather data: {e}")
        return None


def c_to_f(temp_c: float) -> float:
    """Convert Celsius to Fahrenheit."""
    return temp_c * 9.0 / 5.0 + 32.0


def format_temperature_f(temp_c: float) -> str:
    """Return temperature formatted in Fahrenheit with two decimals and °F suffix."""
    temp_f = c_to_f(temp_c)
    return f"{temp_f:.2f}°F"


@app.get("/weather/{city}")
async def get_weather_for_city(city: str):
    """
    FastAPI endpoint: /weather/{city}
    Returns JSON with:
      - city: input city name
      - coordinates: latitude and longitude (rounded to 4 decimals)
      - temperature: Fahrenheit string e.g. "60.76°F"
      - conditions: weather description
    """
    api_key = os.getenv("OPENWEATHER_API_KEY")
    if not api_key:
        raise HTTPException(status_code=500, detail="OpenWeather API key not configured")

    coordinates = get_coordinates(city)
    if not coordinates:
        raise HTTPException(status_code=404, detail=f"City '{city}' not found")

    lat, lon = coordinates
    weather_data = get_weather(lat, lon, api_key)
    if not weather_data:
        raise HTTPException(status_code=500, detail="Failed to fetch weather data")

    # Extract temperature (Celsius) and description
    try:
        temp_c = weather_data["main"]["temp"]
        conditions = weather_data["weather"][0]["description"]
    except (KeyError, IndexError):
        raise HTTPException(status_code=500, detail="Unexpected response format from weather API")

    return {
        "city": city,
        "coordinates": {"latitude": round(lat, 4), "longitude": round(lon, 4)},
        "temperature": format_temperature_f(temp_c),
        "conditions": conditions,
    }


def main():
    # CLI entrypoint: python3 weather.py "New York"
    if len(sys.argv) != 2:
        print("Usage: python3 weather.py \"<city_name>\"")
        sys.exit(1)

    city_name = sys.argv[1]
    api_key = os.getenv("OPENWEATHER_API_KEY")
    if not api_key:
        print("Error: OPENWEATHER_API_KEY environment variable not set")
        sys.exit(1)

    coords = get_coordinates(city_name)
    if not coords:
        print(f"Error: City '{city_name}' not found")
        sys.exit(1)

    lat, lon = coords
    # Set debug=True if you want to see request/response debug logs
    weather_data = get_weather(lat, lon, api_key, debug=False)
    if not weather_data:
        print("Error: Failed to fetch weather data")
        sys.exit(1)

    temp_c = weather_data["main"]["temp"]
    conditions = weather_data["weather"][0]["description"]

    print(f"City: {city_name}")
    print(f"Coordinates: {lat:.4f}, {lon:.4f}")
    print(f"Temperature: {temp_c:.2f}°C / {format_temperature_f(temp_c)}")
    print(f"Conditions: {conditions}")


if __name__ == "__main__":
    main()

python3 -m venv venv
source venv/bin/activate
pip install requests fastapi uvicorn

export OPENWEATHER_API_KEY=your_actual_api_key_here

python3 weather.py "New York"

City: New York
Coordinates: 40.7127, -74.0060
Temperature: 18.93°C / 66.07°F
Conditions: clear sky

uvicorn weather:app --reload

{
  "city": "Forest Grove",
  "coordinates": {
    "latitude": 45.519,
    "longitude": -123.1111
  },
  "temperature": "60.76°F",
  "conditions": "overcast clouds"
}