isobar-cli 1.0.0__py3-none-any.whl

isobar_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.6.2"

isobar_cli/api.py

@@ -0,0 +1,248 @@
+import json
+import time
+from datetime import datetime
+from pathlib import Path
+
+import requests
+from timezonefinder import TimezoneFinder
+
+CACHE_DIR = Path.home() / ".cache" / "isobar"
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def get_cached_cities() -> list[str]:
+    """
+    Returns a list of unique city names from the local cache history.
+    Used for shell completion.
+    """
+    cities = set()
+    if not CACHE_DIR.exists():
+        return []
+
+    for f in CACHE_DIR.glob("*.json"):
+        # Strip unit suffixes and .json extension
+        name = f.stem
+        for suffix in ["_metric", "_imperial"]:
+            if name.endswith(suffix):
+                name = name[: -len(suffix)]
+        # Convert underscores back to spaces for completion
+        cities.add(name.replace("_", " ").title())
+
+    return sorted(cities)
+
+
+def format_time(iso_string: str) -> str:
+    """Convert ISO 8601 datetime to 12-hour format (e.g., '6:42 AM')."""
+    if not iso_string:
+        return "--"
+    try:
+        dt = datetime.fromisoformat(iso_string.replace("Z", "+00:00"))
+        hour = dt.hour
+        minute = dt.minute
+        if hour == 0:
+            hour_12 = 12
+            period = "AM"
+        elif hour < 12:
+            hour_12 = hour
+            period = "AM"
+        elif hour == 12:
+            hour_12 = 12
+            period = "PM"
+        else:
+            hour_12 = hour - 12
+            period = "PM"
+        return f"{hour_12}:{minute:02d} {period}"
+    except (ValueError, AttributeError):
+        return "--"
+
+
+def get_city_suggestions(city: str) -> list[str]:
+    """
+    Fetches a list of likely city name matches for a given input string.
+    Useful for 'Did you mean?' suggestions.
+    """
+    url = (
+        f"https://geocoding-api.open-meteo.com/v1/search"
+        f"?name={city}&count=5&format=json"
+    )
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        data = response.json()
+        if "results" not in data:
+            return []
+
+        suggestions = []
+        for loc in data["results"]:
+            region = loc.get("admin1", loc.get("country", ""))
+            name = f"{loc['name']}, {region}".strip(", ")
+            if name not in suggestions:
+                suggestions.append(name)
+        return suggestions
+    except Exception:
+        return []
+
+
+def get_weather_data(city: str, metric: bool = False) -> dict:
+    """
+    Converts the city name to coordinates, then fetches the weather with precip
+    forecast including rain, snow, sunrise/sunset, WMO weather code, and
+    a 7-day daily forecast.
+    Timezone is resolved dynamically from lat/lon using timezonefinder.
+    """
+    unit_suffix = "_metric" if metric else "_imperial"
+    cache_file = CACHE_DIR / f"{city.lower().replace(' ', '_')}{unit_suffix}.json"
+
+    # Check cache first
+    if cache_file.exists():
+        try:
+            cache_data = json.loads(cache_file.read_text())
+            timestamp = cache_data.get("timestamp", 0)
+            if time.time() - timestamp < 900:  # 15 minutes
+                # Return data with cache metadata
+                cache_data["last_updated"] = timestamp
+                return cache_data
+        except (json.JSONDecodeError, KeyError, ValueError):
+            pass  # Cache invalid, proceed to API
+
+    geo_url = (
+        f"https://geocoding-api.open-meteo.com/v1/search"
+        f"?name={city}&count=1&format=json"
+    )
+
+    try:
+        geo_response = requests.get(geo_url)
+        geo_response.raise_for_status()
+        geo_data = geo_response.json()
+
+        if "results" not in geo_data:
+            return {}
+
+        location = geo_data["results"][0]
+        lat = location["latitude"]
+        lon = location["longitude"]
+        region = location.get("admin1", location.get("country", ""))
+        clean_city_name = f"{location['name']}, {region}".strip(", ")
+
+        # Resolve timezone dynamically from coordinates
+        tf = TimezoneFinder()
+        timezone = tf.timezone_at(lat=lat, lng=lon) or "UTC"
+
+        # Build weather URL — 7-day daily forecast + current conditions
+        temp_unit = "celsius" if metric else "fahrenheit"
+        wind_unit = "kmh" if metric else "mph"
+        precip_unit = "mm" if metric else "inch"
+
+        weather_url = (
+            f"https://api.open-meteo.com/v1/forecast?"
+            f"latitude={lat}&longitude={lon}&"
+            f"current=temperature_2m,apparent_temperature,wind_speed_10m,"
+            f"relative_humidity_2m,precipitation,weather_code&"
+            f"daily=sunrise,sunset,temperature_2m_max,temperature_2m_min,"
+            f"weather_code,precipitation_probability_max&"
+            f"hourly=precipitation_probability,rain,snowfall,temperature_2m,weather_code&"
+            f"temperature_unit={temp_unit}&"
+            f"wind_speed_unit={wind_unit}&precipitation_unit={precip_unit}&"
+            f"timezone={timezone}&forecast_days=7"
+        )
+
+        weather_response = requests.get(weather_url)
+        weather_response.raise_for_status()
+        api_data = weather_response.json()
+
+        # Build Air Quality URL (separate API)
+        aqi_url = (
+            f"https://air-quality-api.open-meteo.com/v1/air-quality?"
+            f"latitude={lat}&longitude={lon}&current=us_aqi"
+        )
+        aqi_value = None
+        try:
+            aqi_response = requests.get(aqi_url)
+            aqi_response.raise_for_status()
+            aqi_data = aqi_response.json()
+            aqi_value = aqi_data.get("current", {}).get("us_aqi")
+        except Exception:
+            pass  # AQI is non-essential, don't fail if API is down
+
+        current = api_data["current"]
+        hourly = api_data["hourly"]
+        daily = api_data["daily"]
+
+        # Find the starting index in hourly data that matches current time (rounded down)
+        current_time_iso = current["time"]
+        try:
+            start_idx = hourly["time"].index(current_time_iso)
+        except ValueError:
+            start_idx = 0
+
+        # Build 24h hourly forecast (from current hour onwards)
+        hourly_forecast = []
+        for i in range(start_idx, min(start_idx + 24, len(hourly["time"]))):
+            hourly_forecast.append(
+                {
+                    "time": hourly["time"][i],
+                    "temp": hourly["temperature_2m"][i],
+                    "weather_code": hourly["weather_code"][i],
+                    "precip_prob": hourly["precipitation_probability"][i],
+                }
+            )
+
+        # Next 6 hours precip probability (average)
+        next_6h_probs = hourly["precipitation_probability"][start_idx : start_idx + 6]
+        avg_precip_prob = (
+            sum(next_6h_probs) / len(next_6h_probs) if next_6h_probs else 0
+        )
+
+        # Next 6 hours rainfall/snowfall (total inches)
+        next_6h_rain = sum(hourly["rain"][start_idx : start_idx + 6])
+        next_6h_snow = sum(hourly["snowfall"][start_idx : start_idx + 6])
+
+        # Build 7-day forecast list (index 0 = today)
+        num_days = len(daily["time"])
+        forecast = []
+        for i in range(num_days):
+            forecast.append(
+                {
+                    "date": daily["time"][i],  # YYYY-MM-DD
+                    "high": daily["temperature_2m_max"][i],
+                    "low": daily["temperature_2m_min"][i],
+                    "weather_code": daily["weather_code"][i],
+                    "precip_prob": daily["precipitation_probability_max"][i] or 0,
+                }
+            )
+
+        current_time = time.time()
+        result = {
+            "city": clean_city_name,
+            "temp": current["temperature_2m"],
+            "feels_like": current["apparent_temperature"],
+            "wind_speed": current["wind_speed_10m"],
+            "humidity": current["relative_humidity_2m"],
+            "precipitation": current["precipitation"],
+            "weather_code": current.get("weather_code", 0),
+            "precip_prob": round(avg_precip_prob),  # % chance next 6h
+            "rainfall": next_6h_rain,  # Total rain next 6h
+            "snowfall": next_6h_snow,  # Total snow next 6h
+            "sunrise": format_time(daily["sunrise"][0]),
+            "sunset": format_time(daily["sunset"][0]),
+            "forecast": forecast,  # List of 7 daily dicts
+            "hourly": hourly_forecast,  # Next 24 hours
+            "aqi": aqi_value,
+            "last_updated": current_time,
+            "units": {
+                "temp": "°C" if metric else "°F",
+                "wind": "km/h" if metric else "mph",
+                "precip": "mm" if metric else "in",
+            },
+        }
+
+        # Cache successful result
+        result_with_ts = result.copy()
+        result_with_ts["timestamp"] = current_time
+        cache_file.write_text(json.dumps(result_with_ts))
+
+        return result
+
+    except requests.exceptions.RequestException as e:
+        print(f"Connection error: {e}")
+        return {}

isobar_cli/location.py

@@ -0,0 +1,30 @@
+"""Location detection module for automatic city detection via IP."""
+
+from typing import Optional
+
+import requests
+
+
+def get_auto_location() -> Optional[str]:
+    """Detect user's location based on their IP address."""
+    try:
+        headers = {
+            "User-Agent": (
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+            )
+        }
+        response = requests.get(
+            "http://ip-api.com/json/",
+            headers=headers,
+            timeout=3,
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        if data.get("status") == "success":
+            return data.get("city")
+
+        return None
+
+    except Exception:
+        return None

isobar_cli/main.py

@@ -0,0 +1,130 @@
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+
+from isobar_cli.api import get_cached_cities, get_city_suggestions, get_weather_data
+from isobar_cli.location import get_auto_location
+from isobar_cli.ui import (
+    display_forecast,
+    display_hourly,
+    display_multi_weather,
+    display_weather,
+)
+
+app = typer.Typer(
+    help=("Terminal weather focused on what it FEELS LIKE outside right now.")
+)
+console = Console()
+
+
+def city_complete(incomplete: str):
+    """Callback for shell completion of city names from cache."""
+    cached = get_cached_cities()
+    return [c for c in cached if c.lower().startswith(incomplete.lower())]
+
+
+@app.command()
+def main(
+    cities: Annotated[
+        Optional[list[str]],
+        typer.Argument(
+            help="City name(s) (detects automatically if omitted). Use quotes for multi-word cities (e.g. \"New York\").",
+            autocompletion=city_complete,
+        ),
+    ] = None,
+    forecast: Annotated[
+        bool,
+        typer.Option(
+            "--forecast",
+            "-f",
+            help="Show 7-day forecast after current conditions",
+        ),
+    ] = False,
+    hourly: Annotated[
+        bool,
+        typer.Option(
+            "--hourly",
+            "-H",
+            help="Show next 12 hours of weather",
+        ),
+    ] = False,
+    metric: Annotated[
+        bool,
+        typer.Option(
+            "--metric",
+            "-m",
+            help="Show weather in metric units (Celsius, km/h, mm)",
+        ),
+    ] = False,
+):
+    """
+    Get the weather and what it FEELS LIKE outside right now.
+
+    Examples:
+        isobar                        # Auto-detect location
+        isobar Chicago                # Single city
+        isobar London Tokyo Paris     # Multiple cities
+        isobar "New York"             # Quotes for multi-word cities
+        isobar --forecast             # Current + 7-day outlook
+        isobar --hourly               # Current + next 12 hours
+        isobar --metric               # Metric units
+    """
+    # Resolve cities list
+    cities_to_fetch = []
+    if cities:
+        cities_to_fetch.extend(cities)
+
+    # Auto-location if no city provided either way
+    if not cities_to_fetch:
+        console.print("[dim]🌍 Detecting location...[/dim]")
+        auto_city = get_auto_location()
+
+        if auto_city is None:
+            console.print(
+                "[yellow]⚠️  Could not detect location. "
+                "Using Chicago as default.[/yellow]"
+            )
+            cities_to_fetch = ["Chicago"]
+        else:
+            console.print(f"[dim]📍 Detected: {auto_city}[/dim]")
+            cities_to_fetch = [auto_city]
+
+    # Process each city
+    results = []
+    for city_name in cities_to_fetch:
+        full_city = city_name.replace("_", " ")
+        weather = get_weather_data(full_city, metric=metric)
+        if weather:
+            results.append(weather)
+        else:
+            console.print(f"[bold red]❌ '{full_city}' not found.[/bold red]")
+            suggestions = get_city_suggestions(full_city)
+            if suggestions:
+                suggest_str = ", ".join(suggestions[:3])
+                console.print(f"[dim]Did you mean: {suggest_str}?[/dim]")
+
+    if not results:
+        raise typer.Exit(code=1)
+
+    # UI Rendering
+    # If multiple cities AND no detail flags, show side-by-side
+    if len(results) > 1 and not (hourly or forecast):
+        display_multi_weather(results)
+    else:
+        # Show sequentially (best for hourly/forecast details)
+        for i, weather in enumerate(results):
+            if i > 0:
+                console.print("[dim]───────────────────────────────────────[/dim]")
+
+            display_weather(weather)
+
+            if hourly:
+                display_hourly(weather)
+
+            if forecast:
+                display_forecast(weather)
+
+
+if __name__ == "__main__":
+    app()

isobar_cli/ui.py

@@ -0,0 +1,366 @@
+import time
+from datetime import datetime
+
+from rich.columns import Columns
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+# WMO Weather interpretation codes -> (emoji, description)
+# https://open-meteo.com/en/docs
+WMO_CODES: dict[int, tuple[str, str]] = {
+    0: ("☀️", "Clear sky"),
+    1: ("🌤️", "Mainly clear"),
+    2: ("⛅", "Partly cloudy"),
+    3: ("☁️", "Overcast"),
+    45: ("🌫️", "Foggy"),
+    48: ("🌫️", "Rime fog"),
+    51: ("🌦️", "Light drizzle"),
+    53: ("🌦️", "Moderate drizzle"),
+    55: ("🌧️", "Dense drizzle"),
+    61: ("🌧️", "Slight rain"),
+    63: ("🌧️", "Moderate rain"),
+    65: ("🌧️", "Heavy rain"),
+    71: ("🌨️", "Slight snow"),
+    73: ("🌨️", "Moderate snow"),
+    75: ("❄️", "Heavy snow"),
+    77: ("🌨️", "Snow grains"),
+    80: ("🌦️", "Slight showers"),
+    81: ("🌧️", "Moderate showers"),
+    82: ("🌧️", "Violent showers"),
+    85: ("🌨️", "Slight snow showers"),
+    86: ("❄️", "Heavy snow showers"),
+    95: ("⛈️", "Thunderstorm"),
+    96: ("⛈️", "Thunderstorm w/ hail"),
+    99: ("⛈️", "Thunderstorm w/ heavy hail"),
+}
+
+
+def get_weather_icon(code: int) -> tuple[str, str]:
+    """Return (emoji, description) for a WMO weather code."""
+    return WMO_CODES.get(code, ("🌡️", "Unknown"))
+
+
+def get_temp_color(temp_val, unit="°F") -> str:
+    """Returns a Rich color tag based on the temperature and unit."""
+    try:
+        t = float(temp_val)
+        if unit == "°C":
+            # Celsius thresholds (approximate F to C conversion)
+            if t < 0:
+                return "bold cyan"
+            if t < 15:
+                return "bold blue"
+            if t < 26:
+                return "bold green"
+            if t < 35:
+                return "bold yellow"
+            return "bold red"
+        else:
+            # Fahrenheit thresholds
+            if t < 32:
+                return "bold cyan"
+            if t < 60:
+                return "bold blue"
+            if t < 80:
+                return "bold green"
+            if t < 95:
+                return "bold yellow"
+            return "bold red"
+    except (ValueError, TypeError):
+        return "white"
+
+
+def get_precip_headline(weather_data: dict) -> str:
+    """Generate a single-line comfort summary for precip decisions."""
+    precip_prob = weather_data.get("precip_prob", 0)
+    rainfall = weather_data.get("rainfall", 0)
+    snowfall = weather_data.get("snowfall", 0)
+    units = weather_data.get("units", {})
+    unit_precip = units.get("precip", "in")
+    total_precip = rainfall + snowfall
+
+    # Use metric thresholds if unit is 'mm'
+    if unit_precip == "mm":
+        low_precip_limit = 2.5
+        med_precip_limit = 6.0
+        high_precip_limit = 19.0
+        snow_precip_limit = 6.0
+    else:
+        low_precip_limit = 0.1
+        med_precip_limit = 0.25
+        high_precip_limit = 0.75
+        snow_precip_limit = 0.25
+
+    if precip_prob < 30:
+        return "Dry conditions expected"
+    elif precip_prob < 60:
+        if total_precip < low_precip_limit:
+            return "Very low precip risk"
+        return "Possible light precip"
+    else:
+        if snowfall > rainfall and snowfall > snow_precip_limit:
+            return "Snowy conditions likely"
+        elif rainfall > high_precip_limit:
+            return "Heavy rain likely"
+        elif rainfall > med_precip_limit:
+            return "Moderate rain likely"
+        else:
+            return "Light rain likely"
+
+    return ""
+
+
+def get_aqi_label(aqi_val: int) -> tuple[str, str]:
+    """Returns (label, color) for a US AQI value."""
+    if aqi_val <= 50:
+        return "Good", "bold green"
+    if aqi_val <= 100:
+        return "Moderate", "bold yellow"
+    if aqi_val <= 150:
+        return "Unhealthy (Sensitive)", "bold orange1"
+    if aqi_val <= 200:
+        return "Unhealthy", "bold red"
+    if aqi_val <= 300:
+        return "Very Unhealthy", "bold purple"
+    return "Hazardous", "bold dark_red"
+
+
+def build_weather_table(weather_data: dict) -> Table:
+    """
+    Constructs the current conditions weather table.
+    """
+    city = weather_data.get("city", "Unknown Location")
+    temp = weather_data.get("temp", "--")
+    feels_like = weather_data.get("feels_like", "--")
+    wind_speed = weather_data.get("wind_speed", "--")
+    humidity = weather_data.get("humidity", "--")
+    precip_prob = weather_data.get("precip_prob", 0)
+    rainfall = weather_data.get("rainfall", 0)
+    snowfall = weather_data.get("snowfall", 0)
+    sunrise = weather_data.get("sunrise", "--")
+    sunset = weather_data.get("sunset", "--")
+    weather_code = weather_data.get("weather_code", 0)
+    units = weather_data.get("units", {"temp": "°F", "wind": "mph", "precip": "in"})
+
+    temp_color = get_temp_color(temp, units["temp"])
+    feels_color = get_temp_color(feels_like, units["temp"])
+    condition_icon, condition_desc = get_weather_icon(weather_code)
+
+    table = Table(
+        title=f"\n[bold white]{city} Weather[/bold white]",
+        show_header=False,
+        box=None,
+        padding=(0, 1),
+    )
+    table.add_column("Icon", justify="center")
+    table.add_column("Label", justify="left")
+    table.add_column("Value", justify="right")
+
+    table.add_row(condition_icon, "Conditions:", f"[bold]{condition_desc}[/bold]")
+    table.add_row(
+        "🌡️", "Temperature:", f"[{temp_color}]{temp}{units['temp']}[/{temp_color}]"
+    )
+    # Determine "Feels Like" label
+    feels_label = "Real Feel:"
+    try:
+        t_actual = float(temp)
+        t_feels = float(feels_like)
+        is_metric = units["temp"] == "°C"
+
+        if is_metric:
+            # Metric thresholds: Wind chill if <= 10°C, Heat index if >= 27°C
+            if t_actual <= 10 and t_feels < t_actual:
+                feels_label = "Wind Chill:"
+            elif t_actual >= 27 and t_feels > t_actual:
+                feels_label = "Heat Index:"
+        else:
+            # Imperial thresholds: Wind chill if <= 50°F, Heat index if >= 80°F
+            if t_actual <= 50 and t_feels < t_actual:
+                feels_label = "Wind Chill:"
+            elif t_actual >= 80 and t_feels > t_actual:
+                feels_label = "Heat Index:"
+    except (ValueError, TypeError):
+        pass
+
+    table.add_row(
+        "🤔", feels_label, f"[{feels_color}]{feels_like}{units['temp']}[/{feels_color}]"
+    )
+    table.add_row("💨", "Wind Speed:", f"{wind_speed} {units['wind']}")
+    table.add_row("💧", "Humidity:", f"{humidity}%")
+
+    aqi = weather_data.get("aqi")
+    if aqi is not None:
+        aqi_label, aqi_color = get_aqi_label(int(aqi))
+        table.add_row("😷", "Air Quality:", f"[{aqi_color}]{aqi} ({aqi_label})[/{aqi_color}]")
+
+    headline = get_precip_headline(weather_data)
+    precip_value = f"{precip_prob}% (6h)"
+    if headline:
+        precip_value += f" | [dim italic yellow]{headline}[/dim italic yellow]"
+    table.add_row("☔", "Precip Chance:", precip_value)
+
+    if rainfall > 0.01:
+        table.add_row("🌧️", "Rain Expected:", f"~{rainfall:.2f}{units['precip']}")
+    if snowfall > 0.01:
+        table.add_row("❄️", "Snow Expected:", f"~{snowfall:.2f}{units['precip']}")
+
+    table.add_row("🌅", "Sunrise:", f"[yellow]{sunrise}[/yellow]")
+    table.add_row("🌇", "Sunset:", f"[orange1]{sunset}[/orange1]")
+
+    return table
+
+
+def display_weather(weather_data: dict):
+    """
+    Renders the current conditions weather card for a single city.
+    """
+    if not weather_data:
+        console.print("[bold red]No weather data available.[/bold red]")
+        return
+
+    # Show "Updated X min ago" if data is from cache
+    last_updated = weather_data.get("last_updated")
+    if last_updated:
+        minutes_ago = int((time.time() - last_updated) / 60)
+        if minutes_ago > 0:
+            console.print(f"[dim]Updated {minutes_ago} min ago[/dim]")
+
+    table = build_weather_table(weather_data)
+    console.print(table)
+    print()
+
+
+def display_multi_weather(weather_list: list[dict]):
+    """
+    Renders multiple weather cards side-by-side using Columns.
+    """
+    tables = []
+    for weather in weather_list:
+        if weather:
+            tables.append(build_weather_table(weather))
+
+    if not tables:
+        console.print("[bold red]No weather data available.[/bold red]")
+        return
+
+    # Show cache info if any city was cached
+    times = [w.get("last_updated") for w in weather_list if w.get("last_updated")]
+    if times:
+        avg_last_updated = sum(times) / len(times)
+        minutes_ago = int((time.time() - avg_last_updated) / 60)
+        if minutes_ago > 0:
+            console.print(f"[dim]Cached data ~{minutes_ago} min ago[/dim]")
+
+    console.print(Columns(tables, equal=True, expand=False))
+    print()
+
+
+def display_forecast(weather_data: dict):
+    """
+    Renders a 7-day forecast table below the current conditions card.
+    """
+    forecast = weather_data.get("forecast", [])
+    if not forecast:
+        console.print("[yellow]No forecast data available.[/yellow]")
+        return
+
+    city = weather_data.get("city", "Unknown Location")
+    units = weather_data.get("units", {"temp": "°F", "wind": "mph", "precip": "in"})
+
+    table = Table(
+        title=f"[bold white]7-Day Forecast — {city}[/bold white]",
+        show_header=True,
+        header_style="bold dim",
+        box=None,
+        padding=(0, 2),
+    )
+    table.add_column("Day", justify="left", min_width=10)
+    table.add_column("", justify="center")  # emoji
+    table.add_column("Conditions", justify="left", min_width=18)
+    table.add_column("High", justify="right")
+    table.add_column("Low", justify="right")
+    table.add_column("Rain%", justify="right")
+
+    for i, day in enumerate(forecast):
+        # Parse date string to get weekday name
+        try:
+            dt = datetime.strptime(day["date"], "%Y-%m-%d")
+            day_label = "Today" if i == 0 else dt.strftime("%a %b %-d")
+        except ValueError:
+            day_label = day["date"]
+
+        icon, desc = get_weather_icon(int(day["weather_code"]))
+        high = day["high"]
+        low = day["low"]
+        precip = int(day["precip_prob"])
+
+        high_color = get_temp_color(high, units["temp"])
+        low_color = get_temp_color(low, units["temp"])
+        rain_color = "cyan" if precip >= 60 else "yellow" if precip >= 30 else "dim"
+
+        table.add_row(
+            f"[bold]{day_label}[/bold]" if i == 0 else day_label,
+            icon,
+            desc,
+            f"[{high_color}]{high}{units['temp']}[/{high_color}]",
+            f"[{low_color}]{low}{units['temp']}[/{low_color}]",
+            f"[{rain_color}]{precip}%[/{rain_color}]",
+        )
+
+    console.print(table)
+    print()
+
+
+def display_hourly(weather_data: dict):
+    """
+    Renders a compact hourly forecast table for the next 12-24 hours.
+    """
+    hourly = weather_data.get("hourly", [])
+    if not hourly:
+        console.print("[yellow]No hourly data available.[/yellow]")
+        return
+
+    city = weather_data.get("city", "Unknown Location")
+    units = weather_data.get("units", {"temp": "°F", "wind": "mph", "precip": "in"})
+
+    table = Table(
+        title=f"[bold white]Hourly Forecast — {city}[/bold white]",
+        show_header=True,
+        header_style="bold dim",
+        box=None,
+        padding=(0, 2),
+    )
+    table.add_column("Time", justify="left")
+    table.add_column("", justify="center")  # emoji
+    table.add_column("Temp", justify="right")
+    table.add_column("Rain%", justify="right")
+    table.add_column("Conditions", justify="left")
+
+    # Show only next 12 hours for compactness
+    for hour in hourly[:12]:
+        try:
+            dt = datetime.fromisoformat(hour["time"].replace("Z", "+00:00"))
+            time_label = dt.strftime("%-I %p")
+        except ValueError:
+            time_label = hour["time"]
+
+        icon, desc = get_weather_icon(int(hour["weather_code"]))
+        temp = hour["temp"]
+        precip = int(hour["precip_prob"])
+
+        temp_color = get_temp_color(temp, units["temp"])
+        rain_color = "cyan" if precip >= 60 else "yellow" if precip >= 30 else "dim"
+
+        table.add_row(
+            time_label,
+            icon,
+            f"[{temp_color}]{temp}{units['temp']}[/{temp_color}]",
+            f"[{rain_color}]{precip}%[/{rain_color}]",
+            f"[dim]{desc}[/dim]",
+        )
+
+    console.print(table)
+    print()

isobar_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: isobar-cli
+Version: 1.0.0
+Summary: A visually pleasing terminal weather tool focusing on Real Feel and Windchill.
+Author: Beau Bremer / KnowOneActual
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/KnowOneActual/isobar-cli
+Project-URL: Repository, https://github.com/KnowOneActual/isobar-cli
+Project-URL: Issues, https://github.com/KnowOneActual/isobar-cli/issues
+Project-URL: Changelog, https://github.com/KnowOneActual/isobar-cli/blob/main/CHANGELOG.md
+Keywords: weather,cli,terminal,meteo,forecast
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: timezonefinder>=6.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: requests-mock>=1.11.0; extra == "test"
+Requires-Dist: pytest-cov>=4.1.0; extra == "test"
+Dynamic: license-file
+
+# Isobar CLI
+
+![CI](https://github.com/KnowOneActual/isobar-cli/actions/workflows/ci.yml/badge.svg)
+![Coverage](https://img.shields.io/badge/coverage-98%25-green)
+![Version](https://img.shields.io/badge/version-0.6.3-blue)
+![Ruff](https://img.shields.io/badge/linting-ruff-purple)
+![Python](https://img.shields.io/badge/python-3.8%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+A terminal weather tool designed to give you a fast, clean sense of what the weather **feels like** outside; right now and for the week ahead. Built with Python and Rich.
+
+## Philosophy
+
+Isobar CLI answers a simple question: **"What does it feel like outside right now, and how do I prepare to be outside?"**
+
+Most weather apps overwhelm you with data. Isobar strips away everything except what matters when you're deciding whether to grab a jacket.
+
+### Design Principles
+- **Essential over comprehensive** — Show Real Feel, not 47 data points
+- **Terminal-native** — Built for quick checks in your workflow
+- **Zero friction** — No API keys, no config files
+- **Information density** — Clean, borderless UI
+- **Intentional features** — Each must answer: *"Does this help understand what it feels like outside?"*
+
+## ✨ Features
+
+- **Auto-Location** — `isobar` detects your city automatically 🌍
+- **Weather Condition Icons** — WMO-standard emoji + plain-English description (☀️ Clear sky, 🌨️ Moderate snow, ⛈️ Thunderstorm)
+- **Real Feel** — Apparent temperature (what it *feels* like)
+- **Air Quality Index** — US AQI with health classifications 😷
+- **7-Day Forecast** — Full week outlook with color-coded highs/lows and daily rain %
+- **Hourly Outlook** — Next 12 hours of temp and rain chance (`--hourly`)
+- **Multiple Cities** — Compare weather across several cities at once (side-by-side)
+- **Smart Suggestions** — Fuzzy city name matching if you make a typo
+- **Shell Completion** — Tab-complete city names from your search history
+- **Dynamic Timezone** — Sunrise/sunset always shown in the city's local time, not yours
+- **Precipitation Forecast** — Next 6h rain/snow chance + totals
+- **Smart Caching** — 15-min cache per city (`~/.cache/isobar/`)
+- **Color-Coded Temps** — Cyan → Blue → Green → Yellow → Red
+- **Metric Support** — `--metric` or `-m` for Celsius, km/h, and mm
+- **No API Keys** — Free Open-Meteo + ip-api.com
+- **Zero Config** — Works instantly after `pip install .`
+
+## 🚀 Installation
+
+```bash
+git clone https://github.com/KnowOneActual/isobar-cli.git
+cd isobar-cli
+pip install .
+```
+
+## 📱 Usage
+
+```bash
+# Auto-detect your location
+isobar
+
+# Specify a city
+isobar Chicago
+isobar London Tokyo Paris     # Multiple cities
+isobar "New York"             # Use quotes for multi-word cities
+
+# Hourly outlook (next 12h)
+isobar --hourly
+isobar -H
+
+# 7-day forecast
+isobar --forecast
+isobar -f
+isobar "San Francisco" --forecast
+isobar -f Sydney
+
+# Metric units (Celsius, km/h, mm)
+isobar --metric
+isobar -m
+isobar Tokyo -m
+```
+
+## ⌨️ Shell Completion
+
+Isobar supports tab-completion for city names based on your search history. To enable it for your shell:
+
+**Zsh:**
+```bash
+isobar --install-completion zsh
+```
+
+**Bash:**
+```bash
+isobar --install-completion bash
+```
+
+*(Note: You may need to restart your terminal after installing completion).*
+
+## 🖥️ Example Output
+
+```
+               Chicago, Illinois Weather
+ ☀️  Conditions:                        Mainly clear
+ 🌡️  Temperature:                             37.1°F
+ 🤔  Real Feel:                               30.4°F
+ 💨  Wind Speed:                             4.3 mph
+ 💧  Humidity:                                   58%
+ ☔  Precip Chance:  0% (6h) | Dry conditions expected
+ 🌅  Sunrise:                                6:29 AM
+ 🌇  Sunset:                                 5:37 PM
+
+           7-Day Forecast — Chicago, Illinois
+  Day            Conditions        High     Low   Rain%
+  Today      ☁️  Overcast         41.7°F  23.9°F    1%
+  Fri Feb 27 ⛅  Partly cloudy    66.4°F  32.4°F    2%
+  Sat Feb 28 🌨️  Moderate snow    44.0°F  26.5°F   38%
+  Sun Mar 1  ☁️  Overcast         29.0°F  26.6°F   36%
+  Mon Mar 2  ☁️  Overcast         33.6°F  27.1°F   36%
+  Tue Mar 3  🌦️  Light drizzle    36.8°F  30.9°F   27%
+  Wed Mar 4  🌦️  Moderate drizzle 41.3°F  33.5°F   46%
+```
+
+## 🛠 Tech Stack
+
+| Tool | Purpose |
+|---|---|
+| [Typer](https://typer.tiangolo.com/) | CLI framework |
+| [Rich](https://github.com/Textualize/rich) | Terminal UI |
+| [Open-Meteo](https://open-meteo.com/) | Weather + forecast data (free, no key) |
+| [ip-api.com](http://ip-api.com/) | Auto-location detection (free) |
+| [timezonefinder](https://github.com/jannikmi/timezonefinder) | Dynamic timezone from coordinates (offline) |
+| [pytest](https://docs.pytest.org/) | Unit testing framework |
+| [requests-mock](https://requests-mock.readthedocs.io/) | Mocking for API testing |
+| [Ruff](https://docs.astral.sh/ruff/) | Linting + formatting |
+| [pip-audit](https://github.com/pypa/pip-audit) | Dependency security scanning (CI) |
+
+## 📈 Project Status
+
+✅ **Phase 1 Complete** — Caching + Auto-Location  
+✅ **Phase 2 Complete** — Precipitation, Sunrise/Sunset, Condition Icons  
+✅ **Phase 3 Complete** — 7-Day Forecast, Dynamic Timezone, `--city` flag  
+✅ **CI/CD** — Ruff lint + security audit on every push and PR  
+See [ROADMAP.md](ROADMAP.md) and [CHANGELOG.md](CHANGELOG.md)
+
+## 🤝 Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). New features must answer: **"Does this help understand what it feels like outside?"**
+
+## 📄 License
+
+MIT. See [LICENSE](LICENSE).

isobar_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+isobar_cli/__init__.py,sha256=jFlbxEJFS0G44LE-yXXVSwXACA1J_NyYDk5E20_2zpc,22
+isobar_cli/api.py,sha256=tgVlubWMOU8Mk6gALdWOjby737ojW9x-jCDuSpKN0OE,8924
+isobar_cli/location.py,sha256=1I26S15CxFkNU1cuOBdcSgnchqsusBgKUPNKxOFyMyM,731
+isobar_cli/main.py,sha256=ZQYauXRGm0QsiD-84Dk81Ff3N4dwbLDumtDOZRa0ShQ,3992
+isobar_cli/ui.py,sha256=NiHJ2-X301nFFqObYRTBMZbunB7wNsWUuYbg0-wvUI0,12439
+isobar_cli-1.0.0.dist-info/licenses/LICENSE,sha256=rYmroasMTQgriaZcEQdHouEPuEgINHgFqIkFg3ERNhA,1084
+isobar_cli-1.0.0.dist-info/METADATA,sha256=uM1Ob8aK-qa9H0lC9rfrDwi95_pE8C-3Fn7m-NbQDvM,7072
+isobar_cli-1.0.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+isobar_cli-1.0.0.dist-info/entry_points.txt,sha256=4jlPgvi0Pd5I35xRD8FH9_YMCnNZagcWUy63343Ak7U,47
+isobar_cli-1.0.0.dist-info/top_level.txt,sha256=qjt_sFiaC2Ljn9Lgrrh2aIHAhpltjhFD72RMUgISPGQ,11
+isobar_cli-1.0.0.dist-info/RECORD,,

isobar_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

isobar_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+isobar = isobar_cli.main:app

isobar_cli-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Beau Bremer / KnowOneActual
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

isobar_cli-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+isobar_cli