isobar-cli 1.3.2__tar.gz → 1.3.3__tar.gz

{isobar_cli-1.3.2/src/isobar_cli.egg-info → isobar_cli-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isobar-cli
-Version: 1.3.2
+Version: 1.3.3
 Summary: A terminal weather tool with industrial aesthetic, focusing on Real Feel and Windchill.
 Author: Beau Bremer / KnowOneActual
 License-Expression: MIT

{isobar_cli-1.3.2 → isobar_cli-1.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "isobar-cli"
-version = "1.3.2"
+version = "1.3.3"
 description = "A terminal weather tool with industrial aesthetic, focusing on Real Feel and Windchill."
 authors = [
   { name="Beau Bremer / KnowOneActual" },

isobar_cli-1.3.3/src/isobar_cli/__init__.py

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

{isobar_cli-1.3.2 → isobar_cli-1.3.3}/src/isobar_cli/logic.py

@@ -308,3 +308,127 @@ def get_temporal_context(
         return f"{direction} {abs_diff:.1f}°C {'warmer' if diff > 0 else 'cooler'} than yesterday"
     else:
         return f"{direction} {abs_diff:.1f}°F {'warmer' if diff > 0 else 'cooler'} than yesterday"
+
+
+def get_temperature_comfort(temp: float, unit: str = "°F") -> tuple[str, str]:
+    """Get temperature comfort category and color.
+
+    Args:
+        temp: Temperature value
+        unit: Temperature unit (°F or °C)
+
+    Returns:
+        Tuple of (category, color) where category is a comfort level
+    """
+    if unit == "°F":
+        if temp < 32:
+            return "FREEZING", "bright_cyan"
+        elif temp < 50:
+            return "COLD", "cyan"
+        elif temp < 75:
+            return "COMFORTABLE", "bright_green"
+        elif temp < 90:
+            return "WARM", "bright_yellow"
+        else:
+            return "HOT", "bright_red"
+    else:  # °C
+        if temp < 0:
+            return "FREEZING", "bright_cyan"
+        elif temp < 10:
+            return "COLD", "cyan"
+        elif temp < 24:
+            return "COMFORTABLE", "bright_green"
+        elif temp < 32:
+            return "WARM", "bright_yellow"
+        else:
+            return "HOT", "bright_red"
+
+
+def get_humidity_category(humidity: int) -> tuple[str, str]:
+    """Get humidity category and color.
+
+    Args:
+        humidity: Humidity percentage (0-100)
+
+    Returns:
+        Tuple of (category, color)
+    """
+    if humidity < 30:
+        return "DRY", "bright_yellow"
+    elif humidity < 60:
+        return "IDEAL", "bright_green"
+    elif humidity < 80:
+        return "HUMID", "bright_yellow"
+    else:
+        return "MUGGY", "bright_red"
+
+
+def get_wind_category_label(speed: float, unit: str) -> tuple[str, str]:
+    """Get wind category label and color.
+
+    Args:
+        speed: Wind speed
+        unit: Wind unit (mph or km/h)
+
+    Returns:
+        Tuple of (category, color)
+    """
+    if unit == "mph":
+        if speed < 1:
+            return "CALM", "bright_cyan"
+        elif speed < 7:
+            return "LIGHT", "cyan"
+        elif speed < 12:
+            return "GENTLE", "bright_green"
+        elif speed < 18:
+            return "MODERATE", "bright_yellow"
+        elif speed < 24:
+            return "FRESH", "yellow"
+        elif speed < 31:
+            return "STRONG", "bright_red"
+        elif speed < 38:
+            return "GALE", "red"
+        elif speed < 46:
+            return "SEVERE", "bright_red"
+        else:
+            return "STORM", "bright_red"
+    else:  # km/h
+        if speed < 2:
+            return "CALM", "bright_cyan"
+        elif speed < 12:
+            return "LIGHT", "cyan"
+        elif speed < 20:
+            return "GENTLE", "bright_green"
+        elif speed < 29:
+            return "MODERATE", "bright_yellow"
+        elif speed < 39:
+            return "FRESH", "yellow"
+        elif speed < 50:
+            return "STRONG", "bright_red"
+        elif speed < 62:
+            return "GALE", "red"
+        elif speed < 75:
+            return "SEVERE", "bright_red"
+        else:
+            return "STORM", "bright_red"
+
+
+def get_uv_category(uv_index: float) -> tuple[str, str]:
+    """Get UV index category and color.
+
+    Args:
+        uv_index: UV index value
+
+    Returns:
+        Tuple of (category, color)
+    """
+    if uv_index <= 2:
+        return "LOW", "bright_green"
+    elif uv_index <= 5:
+        return "MODERATE", "bright_yellow"
+    elif uv_index <= 7:
+        return "HIGH", "bright_red"
+    elif uv_index <= 10:
+        return "VERY HIGH", "red"
+    else:
+        return "EXTREME", "bright_red"

{isobar_cli-1.3.2 → isobar_cli-1.3.3}/src/isobar_cli/ui.py

@@ -1,6 +1,5 @@
 import time
 
-from rich import box
 from rich.columns import Columns
 from rich.console import Console
 from rich.table import Table
@@ -9,11 +8,13 @@ from .logic import (
     WMO_CODES,
     get_aqi_label,
     get_feels_like_label,
-    get_precip_headline,
+    get_humidity_category,
     get_preparation_guidance,
     get_temp_color,
+    get_temperature_comfort,
     get_temporal_context,
-    get_uv_guidance,
+    get_uv_category,
+    get_wind_category_label,
     get_wind_gust_alert,
 )
 from .models import WeatherData
@@ -34,15 +35,6 @@ COLORS = {
     "concrete": "white",
 }
 
-# Weather severity indicators
-SEVERITY_ICONS = {
-    "extreme": "⚡",
-    "high": "▲",
-    "medium": "●",
-    "low": "○",
-    "normal": "◇",
-}
-
 
 def get_weather_icon(code: int) -> tuple[str, str]:
     """Return (emoji, description) for a WMO weather code."""
@@ -50,7 +42,7 @@ def get_weather_icon(code: int) -> tuple[str, str]:
 
 
 def build_weather_table(weather: WeatherData) -> Table:
-    """Constructs the current conditions weather table with industrial aesthetic."""
+    """Constructs the current conditions weather table with borderless industrial aesthetic."""
     icon, desc = get_weather_icon(weather.weather_code)
     temp_color = get_temp_color(weather.temp, weather.units.temp)
     feels_color = get_temp_color(weather.feels_like, weather.units.temp)
@@ -58,47 +50,50 @@ def build_weather_table(weather: WeatherData) -> Table:
         weather.temp, weather.feels_like, weather.units.temp
     )
 
-    # Create industrial-style table with heavy borders
+    # Get meaningful labels for weather data
+    temp_comfort, temp_comfort_color = get_temperature_comfort(
+        weather.temp, weather.units.temp
+    )
+    humidity_category, humidity_color = get_humidity_category(weather.humidity)
+    wind_category, wind_color = get_wind_category_label(
+        weather.wind_speed, weather.units.wind
+    )
+
+    # Create borderless industrial-style table
     table = Table(
-        title=f"[{COLORS['primary']} bold]┌─ WEATHER OBSERVATORY ─┐[/{COLORS['primary']} bold]\n"
-        f"[{COLORS['steel']}]{weather.city.upper()}[/{COLORS['steel']}]",
+        title=f"[{COLORS['primary']} bold]WEATHER OBSERVATORY · {weather.city.upper()}[/{COLORS['primary']} bold]",
         show_header=False,
-        box=box.HEAVY,
-        border_style=COLORS["secondary"],
-        title_style=f"{COLORS['primary']} bold",
-        padding=(0, 2),
+        box=None,  # No borders
+        padding=(0, 1),
         width=60,
+        title_style=f"{COLORS['primary']} bold",
     )
 
-    # Add columns with industrial styling
-    table.add_column("", justify="center", width=4, style=COLORS["accent"])
-    table.add_column("METRIC", justify="left", width=20, style=COLORS["muted"])
-    table.add_column("READING", justify="right", width=15, style=COLORS["primary"])
-    table.add_column("STATUS", justify="right", width=15, style=COLORS["secondary"])
-
-    # Weather condition row with severity indicator
-    severity = (
-        "medium" if weather.weather_code in [95, 96, 99, 65, 75, 86] else "normal"
+    # Add columns: icon, metric, value, category
+    table.add_column("", justify="center", width=3, style=COLORS["accent"])
+    table.add_column(
+        "METRIC", justify="left", width=18, style=f"{COLORS['muted']} bold"
     )
+    table.add_column("VALUE", justify="right", width=12, style=COLORS["primary"])
+    table.add_column("CATEGORY", justify="right", width=20, style=COLORS["secondary"])
+
+    # Weather condition
     table.add_row(
         f"[{COLORS['accent']}]{icon}[/{COLORS['accent']}]",
-        "[bold]CONDITIONS[/bold]",
-        f"[{COLORS['primary']} bold]{desc.upper()}[/{COLORS['primary']} bold]",
-        f"[{COLORS['warning']}]{SEVERITY_ICONS[severity]}[/{COLORS['warning']}]",
+        "CONDITIONS",
+        f"[{COLORS['primary']}]{desc.upper()}[/{COLORS['primary']}]",
+        "",
     )
 
-    # Temperature with industrial gauge visualization
-    temp_gauge = create_gauge(
-        weather.temp, weather.units.temp, 100 if weather.units.temp == "°F" else 40
-    )
+    # Temperature with comfort category
     table.add_row(
         "🌡️",
-        "[bold]TEMPERATURE[/bold]",
+        "TEMPERATURE",
         f"[{temp_color}]{weather.temp}{weather.units.temp}[/{temp_color}]",
-        temp_gauge,
+        f"[{temp_comfort_color}]{temp_comfort}[/{temp_comfort_color}]",
     )
 
-    # Feels like with difference indicator
+    # Feels like with difference
     temp_diff = weather.feels_like - weather.temp
     diff_symbol = "▲" if temp_diff > 0 else "▼" if temp_diff < 0 else "▬"
     diff_color = (
@@ -108,195 +103,115 @@ def build_weather_table(weather: WeatherData) -> Table:
         if temp_diff < -5
         else COLORS["muted"]
     )
+    feels_comfort, feels_comfort_color = get_temperature_comfort(
+        weather.feels_like, weather.units.temp
+    )
     table.add_row(
         "🤔",
-        f"[bold]{feels_label.upper()}[/bold]",
+        f"{feels_label.upper()}",
         f"[{feels_color}]{weather.feels_like}{weather.units.temp}[/{feels_color}]",
-        f"[{diff_color}]{diff_symbol} {abs(temp_diff):.1f}{weather.units.temp}[/{diff_color}]",
+        f"[{feels_comfort_color}]{feels_comfort} [{diff_color}]{diff_symbol}{abs(temp_diff):.1f}{weather.units.temp}[/{diff_color}][/{feels_comfort_color}]",
     )
 
-    # Wind with speed category
-    wind_category = get_wind_category(weather.wind_speed, weather.units.wind)
+    # Wind with category
     table.add_row(
         "💨",
-        "[bold]WIND SPEED[/bold]",
+        "WIND SPEED",
         f"{weather.wind_speed} {weather.units.wind}",
-        f"[{COLORS['steel']}]{wind_category}[/{COLORS['steel']}]",
+        f"[{wind_color}]{wind_category}[/{wind_color}]",
     )
 
-    # Humidity with moisture indicator
-    humidity_indicator = "▓" * (weather.humidity // 20) + "░" * (
-        5 - weather.humidity // 20
-    )
+    # Humidity with category
     table.add_row(
         "💧",
-        "[bold]HUMIDITY[/bold]",
+        "HUMIDITY",
         f"{weather.humidity}%",
-        f"[{COLORS['accent']}]{humidity_indicator}[/{COLORS['accent']}]",
+        f"[{humidity_color}]{humidity_category}[/{humidity_color}]",
     )
 
-    # Air Quality with health impact
+    # Air Quality
     if weather.aqi is not None:
         label, color = get_aqi_label(weather.aqi)
-        aqi_severity = (
-            "high" if weather.aqi > 100 else "medium" if weather.aqi > 50 else "low"
-        )
         table.add_row(
             "😷",
-            "[bold]AIR QUALITY[/bold]",
+            "AIR QUALITY",
             f"[{color}]{weather.aqi}[/{color}]",
-            f"[{color}]{label.upper()} {SEVERITY_ICONS[aqi_severity]}[/{color}]",
+            f"[{color}]{label.upper()}[/{color}]",
         )
 
-    # Precipitation with visual indicator
-    precip_indicator = "●" * min(weather.precip_prob // 20, 5)
-    headline = get_precip_headline(
-        weather.precip_prob, weather.rainfall, weather.snowfall, weather.units.precip
+    # Precipitation
+    precip_category = (
+        "DRY"
+        if weather.precip_prob < 20
+        else "LIGHT"
+        if weather.precip_prob < 50
+        else "MODERATE"
+        if weather.precip_prob < 80
+        else "HEAVY"
+    )
+    precip_color = (
+        COLORS["success"]
+        if weather.precip_prob < 20
+        else COLORS["warning"]
+        if weather.precip_prob < 50
+        else COLORS["danger"]
     )
     table.add_row(
         "☔",
-        "[bold]PRECIPITATION[/bold]",
+        "PRECIPITATION",
         f"{weather.precip_prob}% (6h)",
-        f"[{COLORS['accent']}]{precip_indicator}[/{COLORS['accent']}]",
+        f"[{precip_color}]{precip_category}[/{precip_color}]",
     )
 
-    if headline:
-        table.add_row(
-            "",
-            "[dim]FORECAST[/dim]",
-            f"[{COLORS['warning']} italic]{headline.upper()}[/{COLORS['warning']} italic]",
-            "",
-        )
-
-    # Sunrise/Sunset with day progress
+    # Sunrise/Sunset
     table.add_row(
         "🌅",
-        "[bold]SUNRISE[/bold]",
+        "SUNRISE",
         f"[{COLORS['warning']}]{weather.sunrise}[/{COLORS['warning']}]",
-        "[dim]DAWN[/dim]",
+        "",
     )
 
     table.add_row(
         "🌇",
-        "[bold]SUNSET[/bold]",
+        "SUNSET",
         f"[{COLORS['danger']}]{weather.sunset}[/{COLORS['danger']}]",
-        "[dim]DUSK[/dim]",
+        "",
     )
 
-    # UV Index with protection level
+    # UV Index
     if weather.uv_index is not None:
-        uv_label, uv_color = get_uv_guidance(weather.uv_index)
-        uv_level = min(int(weather.uv_index / 2), 5)
-        uv_indicator = "☀️" * uv_level
+        uv_category, uv_color = get_uv_category(weather.uv_index)
         table.add_row(
             "☀️",
-            "[bold]UV INDEX[/bold]",
+            "UV INDEX",
             f"[{uv_color}]{weather.uv_index:.1f}[/{uv_color}]",
-            f"[{uv_color}]{uv_label.upper()} {uv_indicator}[/{uv_color}]",
+            f"[{uv_color}]{uv_category}[/{uv_color}]",
         )
 
-    # Wind Gust with alert styling
+    # Wind Gust
     if weather.wind_gust is not None:
         gust_alert = get_wind_gust_alert(weather.wind_speed, weather.wind_gust)
+        gust_category, gust_color = get_wind_category_label(
+            weather.wind_gust, weather.units.wind
+        )
         if gust_alert:
             table.add_row(
                 "⚡",
                 "[bold yellow]GUST ALERT[/bold yellow]",
                 f"[bold yellow]{weather.wind_gust} {weather.units.wind}[/bold yellow]",
-                "[bold yellow]⚠️ SEVERE[/bold yellow]",
+                f"[bold yellow]{gust_category} ⚠️[/bold yellow]",
             )
         else:
-            gust_ratio = (
-                weather.wind_gust / weather.wind_speed if weather.wind_speed > 0 else 1
-            )
-            gust_indicator = "!" * min(int(gust_ratio * 2), 3)
             table.add_row(
                 "💨",
-                "[bold]WIND GUST[/bold]",
+                "WIND GUST",
                 f"{weather.wind_gust} {weather.units.wind}",
-                f"[{COLORS['steel']}]{gust_indicator}[/{COLORS['steel']}]",
+                f"[{gust_color}]{gust_category}[/{gust_color}]",
             )
 
     return table
 
 
-def create_gauge(value: float, unit: str, max_value: float) -> str:
-    """Create a text-based gauge visualization."""
-    if unit == "°F":
-        ranges = [
-            (32, "bold cyan"),
-            (60, "bold blue"),
-            (80, "bold green"),
-            (95, "bold yellow"),
-            (max_value, "bold red"),
-        ]
-    else:
-        ranges = [
-            (0, "bold cyan"),
-            (15, "bold blue"),
-            (26, "bold green"),
-            (35, "bold yellow"),
-            (max_value, "bold red"),
-        ]
-
-    # Find appropriate color
-    gauge_color = "bold white"
-    for threshold, color in ranges:
-        if value <= threshold:
-            gauge_color = color
-            break
-
-    # Create gauge visualization
-    gauge_width = 10
-    filled = min(int((value / max_value) * gauge_width), gauge_width)
-    gauge = "[" + gauge_color + "]" + "█" * filled + "[/" + gauge_color + "]"
-    gauge += "[dim]" + "░" * (gauge_width - filled) + "[/dim]"
-
-    return gauge
-
-
-def get_wind_category(speed: float, unit: str) -> str:
-    """Categorize wind speed."""
-    if unit == "mph":
-        if speed < 1:
-            return "CALM"
-        elif speed < 7:
-            return "LIGHT"
-        elif speed < 12:
-            return "GENTLE"
-        elif speed < 18:
-            return "MODERATE"
-        elif speed < 24:
-            return "FRESH"
-        elif speed < 31:
-            return "STRONG"
-        elif speed < 38:
-            return "GALE"
-        elif speed < 46:
-            return "SEVERE"
-        else:
-            return "STORM"
-    else:  # km/h
-        if speed < 2:
-            return "CALM"
-        elif speed < 12:
-            return "LIGHT"
-        elif speed < 20:
-            return "GENTLE"
-        elif speed < 29:
-            return "MODERATE"
-        elif speed < 39:
-            return "FRESH"
-        elif speed < 50:
-            return "STRONG"
-        elif speed < 62:
-            return "GALE"
-        elif speed < 75:
-            return "SEVERE"
-        else:
-            return "STORM"
-
-
 def display_weather(weather: WeatherData):
     """Renders the current conditions weather card for a single city."""
     if not weather:
@@ -339,19 +254,28 @@ def display_preparation_guidance(weather: WeatherData):
 
     if temporal_context:
         console.print(
-            f"[{COLORS['secondary']}]┌─ TREND ANALYSIS ─┐[/{COLORS['secondary']}]"
+            f"[{COLORS['muted']}]────────────────────────────────────────[/{COLORS['muted']}]"
+        )
+        console.print(
+            f"[{COLORS['primary']} bold]TREND ANALYSIS[/{COLORS['primary']} bold]"
         )
         console.print(
             f"[{COLORS['muted']}]{temporal_context.upper()}[/{COLORS['muted']}]"
         )
         console.print(
-            f"[{COLORS['secondary']}]└──────────────────┘[/{COLORS['secondary']}]"
+            f"[{COLORS['muted']}]────────────────────────────────────────[/{COLORS['muted']}]"
         )
         print()
 
-    # Create industrial guidance panel
+    # Create borderless guidance panel
     console.print(
-        f"[{COLORS['primary']} bold]┌─ PREPARATION PROTOCOL ─┐[/{COLORS['primary']} bold]"
+        f"[{COLORS['muted']}]────────────────────────────────────────[/{COLORS['muted']}]"
+    )
+    console.print(
+        f"[{COLORS['primary']} bold]PREPARATION PROTOCOL[/{COLORS['primary']} bold]"
+    )
+    console.print(
+        f"[{COLORS['muted']}]────────────────────────────────────────[/{COLORS['muted']}]"
     )
 
     # Categorize suggestions by priority
@@ -376,33 +300,31 @@ def display_preparation_guidance(weather: WeatherData):
     # Display high priority items with danger styling
     if high_priority:
         console.print(
-            f"[{COLORS['danger']} bold]  ⚠️  HIGH PRIORITY[/{COLORS['danger']} bold]"
+            f"[{COLORS['danger']} bold]⚠️  HIGH PRIORITY[/{COLORS['danger']} bold]"
         )
         for suggestion in high_priority:
-            console.print(
-                f"    [{COLORS['danger']}]▶[/{COLORS['danger']}] {suggestion}"
-            )
+            console.print(f"  [{COLORS['danger']}]▶[/{COLORS['danger']}] {suggestion}")
         print()
 
     # Display medium priority items with warning styling
     if medium_priority:
         console.print(
-            f"[{COLORS['warning']} bold]  ▲  RECOMMENDED[/{COLORS['warning']} bold]"
+            f"[{COLORS['warning']} bold]▲  RECOMMENDED[/{COLORS['warning']} bold]"
         )
         for suggestion in medium_priority:
             console.print(
-                f"    [{COLORS['warning']}]▶[/{COLORS['warning']}] {suggestion}"
+                f"  [{COLORS['warning']}]▶[/{COLORS['warning']}] {suggestion}"
             )
         print()
 
     # Display low priority items with muted styling
     if low_priority:
-        console.print(f"[{COLORS['muted']} bold]  ○  ADVISORY[/{COLORS['muted']} bold]")
+        console.print(f"[{COLORS['muted']} bold]○  ADVISORY[/{COLORS['muted']} bold]")
         for suggestion in low_priority:
-            console.print(f"    [{COLORS['muted']}]▶[/{COLORS['muted']}] {suggestion}")
+            console.print(f"  [{COLORS['muted']}]▶[/{COLORS['muted']}] {suggestion}")
 
     console.print(
-        f"[{COLORS['primary']} bold]└─────────────────────────┘[/{COLORS['primary']} bold]"
+        f"[{COLORS['muted']}]────────────────────────────────────────[/{COLORS['muted']}]"
     )
 
 
@@ -425,39 +347,34 @@ def display_multi_weather(weather_list: list[WeatherData]):
 
 
 def display_forecast(weather: WeatherData):
-    """Renders a 7-day forecast table with industrial aesthetic."""
+    """Renders a 7-day forecast table with borderless industrial aesthetic."""
     if not weather.forecast:
         console.print(
             f"[{COLORS['warning']}]No forecast data available.[/{COLORS['warning']}]"
         )
         return
 
-    # Create industrial forecast table
+    # Create borderless forecast table
     table = Table(
-        title=f"[{COLORS['primary']} bold]┌─ FORECAST PANEL ─┐[/{COLORS['primary']} bold]\n"
-        f"[{COLORS['steel']}]{weather.city.upper()}[/{COLORS['steel']}]",
+        title=f"[{COLORS['primary']} bold]FORECAST PANEL · {weather.city.upper()}[/{COLORS['primary']} bold]",
         show_header=True,
+        box=None,  # No borders
         header_style=f"{COLORS['muted']} bold",
-        box=box.HEAVY,
-        border_style=COLORS["secondary"],
         padding=(0, 1),
         width=70,
     )
 
-    # Industrial column headers
-    table.add_column("DAY", justify="left", width=12, style=f"{COLORS['accent']} bold")
+    # Borderless column headers
+    table.add_column("DAY", justify="left", width=10, style=f"{COLORS['accent']} bold")
     table.add_column("", justify="center", width=2, style=COLORS["accent"])
-    table.add_column("CONDITIONS", justify="left", width=20, style=COLORS["muted"])
+    table.add_column("CONDITIONS", justify="left", width=18, style=COLORS["muted"])
     table.add_column(
-        "HIGH", justify="right", width=10, style=f"{COLORS['primary']} bold"
-    )
-    table.add_column(
-        "LOW", justify="right", width=10, style=f"{COLORS['primary']} bold"
+        "HIGH", justify="right", width=8, style=f"{COLORS['primary']} bold"
     )
+    table.add_column("LOW", justify="right", width=8, style=f"{COLORS['primary']} bold")
     table.add_column(
         "RAIN%", justify="right", width=8, style=f"{COLORS['accent']} bold"
     )
-    table.add_column("STATUS", justify="center", width=8, style=COLORS["secondary"])
 
     for i, day in enumerate(weather.forecast):
         day_label = "TODAY" if i == 0 else day.dt.strftime("%a").upper()
@@ -467,7 +384,7 @@ def display_forecast(weather: WeatherData):
         high_color = get_temp_color(day.high, weather.units.temp)
         low_color = get_temp_color(day.low, weather.units.temp)
 
-        # Precipitation severity indicator
+        # Precipitation color based on probability
         if day.precip_prob >= 70:
             rain_color = COLORS["danger"]
         elif day.precip_prob >= 40:
@@ -477,17 +394,6 @@ def display_forecast(weather: WeatherData):
         else:
             rain_color = COLORS["muted"]
 
-        # Day severity based on weather conditions
-        if day.weather_code in [95, 96, 99, 65, 75, 86]:
-            day_severity = "▲"
-            severity_color = COLORS["warning"]
-        elif day.precip_prob > 60:
-            day_severity = "●"
-            severity_color = COLORS["accent"]
-        else:
-            day_severity = "○"
-            severity_color = COLORS["success"]
-
         table.add_row(
             f"[{COLORS['primary']} bold]{day_label}[/{COLORS['primary']} bold]"
             if i == 0
@@ -497,7 +403,6 @@ def display_forecast(weather: WeatherData):
             f"[{high_color}]{day.high}{weather.units.temp}[/{high_color}]",
             f"[{low_color}]{day.low}{weather.units.temp}[/{low_color}]",
             f"[{rain_color}]{day.precip_prob}%[/{rain_color}]",
-            f"[{severity_color}]{day_severity}[/{severity_color}]",
         )
 
     console.print(table)
@@ -505,49 +410,40 @@ def display_forecast(weather: WeatherData):
 
 
 def display_hourly(weather: WeatherData):
-    """Renders an hourly forecast table with industrial aesthetic."""
+    """Renders an hourly forecast table with borderless industrial aesthetic."""
     if not weather.hourly:
         console.print(
             f"[{COLORS['warning']}]No hourly data available.[/{COLORS['warning']}]"
         )
         return
 
-    # Create industrial hourly table
+    # Create borderless hourly table
     table = Table(
-        title=f"[{COLORS['primary']} bold]┌─ HOURLY TRACKER ─┐[/{COLORS['primary']} bold]\n"
-        f"[{COLORS['steel']}]{weather.city.upper()}[/{COLORS['steel']}]",
+        title=f"[{COLORS['primary']} bold]HOURLY FORECAST · {weather.city.upper()}[/{COLORS['primary']} bold]",
         show_header=True,
+        box=None,  # No borders
         header_style=f"{COLORS['muted']} bold",
-        box=box.HEAVY,
-        border_style=COLORS["secondary"],
         padding=(0, 1),
-        width=65,
+        width=60,
     )
 
-    # Industrial column headers
-    table.add_column("TIME", justify="left", width=8, style=f"{COLORS['accent']} bold")
+    # Simplified column headers
+    table.add_column("TIME", justify="left", width=6, style=f"{COLORS['accent']} bold")
     table.add_column("", justify="center", width=2, style=COLORS["accent"])
     table.add_column(
-        "TEMP", justify="right", width=10, style=f"{COLORS['primary']} bold"
+        "TEMP", justify="right", width=8, style=f"{COLORS['primary']} bold"
     )
-    table.add_column("GAUGE", justify="left", width=12, style=COLORS["muted"])
     table.add_column(
-        "RAIN%", justify="right", width=8, style=f"{COLORS['accent']} bold"
+        "RAIN%", justify="right", width=6, style=f"{COLORS['accent']} bold"
     )
-    table.add_column("CONDITIONS", justify="left", width=20, style=COLORS["concrete"])
-    table.add_column("", justify="center", width=2, style=COLORS["secondary"])
+    table.add_column("CONDITIONS", justify="left", width=18, style=COLORS["concrete"])
 
     for hour in weather.hourly[:12]:
         time_label = hour.dt.strftime("%-I%p").upper()
         icon, desc = get_weather_icon(hour.weather_code)
         temp_color = get_temp_color(hour.temp, weather.units.temp)
 
-        # Temperature gauge
-        temp_gauge = create_gauge(
-            hour.temp, weather.units.temp, 100 if weather.units.temp == "°F" else 40
-        )
-
-        # Precipitation indicator
+        # Precipitation color
         if hour.precip_prob >= 70:
             rain_color = COLORS["danger"]
         elif hour.precip_prob >= 40:
@@ -557,25 +453,12 @@ def display_hourly(weather: WeatherData):
         else:
             rain_color = COLORS["muted"]
 
-        # Hour severity indicator
-        if hour.weather_code in [95, 96, 99]:
-            severity_icon = "⚡"
-            severity_color = COLORS["warning"]
-        elif hour.precip_prob > 60:
-            severity_icon = "☔"
-            severity_color = COLORS["accent"]
-        else:
-            severity_icon = "○"
-            severity_color = COLORS["success"]
-
         table.add_row(
             f"[{COLORS['muted']}]{time_label}[/{COLORS['muted']}]",
             f"[{COLORS['accent']}]{icon}[/{COLORS['accent']}]",
             f"[{temp_color}]{hour.temp}{weather.units.temp}[/{temp_color}]",
-            temp_gauge,
             f"[{rain_color}]{hour.precip_prob}%[/{rain_color}]",
             f"[{COLORS['concrete']}]{desc.upper()}[/{COLORS['concrete']}]",
-            f"[{severity_color}]{severity_icon}[/{severity_color}]",
         )
 
     console.print(table)

{isobar_cli-1.3.2 → isobar_cli-1.3.3/src/isobar_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isobar-cli
-Version: 1.3.2
+Version: 1.3.3
 Summary: A terminal weather tool with industrial aesthetic, focusing on Real Feel and Windchill.
 Author: Beau Bremer / KnowOneActual
 License-Expression: MIT

{isobar_cli-1.3.2 → isobar_cli-1.3.3}/tests/test_isobar_extra.py

@@ -380,8 +380,8 @@ def test_main_with_flags(monkeypatch):
         env={"TERM": "dumb", "NO_COLOR": "1"},
     )
     assert result.exit_code == 0
-    # In industrial aesthetic, hourly display has "HOURLY TRACKER" header
-    assert "HOURLY TRACKER" in result.output.upper()
+    # In borderless industrial aesthetic, hourly display has "HOURLY FORECAST" header
+    assert "HOURLY FORECAST" in result.output.upper()
     assert "CITYH" in result.output.upper()
 
     # Forecast
@@ -572,8 +572,8 @@ def test_display_multi_weather(mock_cache_dir):
 
 
 def test_get_precip_headline_extra():
-    assert ui.get_precip_headline(80, 0.5, 0, "in") == "Moderate rain likely"
-    assert ui.get_precip_headline(80, 0.1, 0, "in") == "Light rain likely"
+    assert logic.get_precip_headline(80, 0.5, 0, "in") == "Moderate rain likely"
+    assert logic.get_precip_headline(80, 0.1, 0, "in") == "Light rain likely"
 
 
 def test_build_weather_table_extra():

{isobar_cli-1.3.2 → isobar_cli-1.3.3}/tests/test_ui.py

@@ -1,8 +1,8 @@
+from isobar_cli.logic import get_precip_headline
 from isobar_cli.models import WeatherData, WeatherUnits
 from isobar_cli.ui import (
     build_weather_table,
     get_aqi_label,
-    get_precip_headline,
     get_temp_color,
     get_weather_icon,
 )

isobar_cli-1.3.2/src/isobar_cli/__init__.py

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