nowcastingcli 0.6.1__py3-none-any.whl

nowcastingcli/__init__.py

@@ -0,0 +1,12 @@
+"""NowcastingCLI package root.
+
+Exposes ``__version__``, read from installed package metadata rather than
+hardcoded, so it always matches what was installed.
+"""
+
+from importlib.metadata import version
+
+# Must match [project] name in pyproject.toml exactly ("nowcastingcli", not
+# the module path: "nowcastingcli.main:cli"); only resolves once the package is installed.
+__version__ = version("nowcastingcli")
+

nowcastingcli/display.py

@@ -0,0 +1,160 @@
+from datetime import datetime
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich import box
+
+from .models import Observation, OBSERVATION_UNITS
+from .heuristics import WORSENING, IMPROVING, STABLE, assess_conditions
+
+# setup_logging()  is called in main.py before this module is imported — handlers already registered.
+import logging
+logger = logging.getLogger(__name__)
+
+console = Console()
+
+VERDICT_STYLE = {
+    WORSENING: ("🔴 CONDITIONS WORSENING", "bold red"),
+    IMPROVING: ("🟢 CONDITIONS IMPROVING", "bold green"),
+    STABLE:    ("🟡 CONDITIONS STABLE",    "bold yellow"),
+}
+
+SPARKLINE_CHARS = "▁▂▃▄▅▆▇█"
+
+
+
+
+def format_observation(obs: Observation) -> str:
+    """Format a single Observation as an indented, human-readable multi-line string.
+
+    Args:
+        obs: The Observation to format.
+
+    Returns:
+        A multi-line string with one field per line, each annotated with its unit
+        from OBSERVATION_UNITS.
+    """
+    u = OBSERVATION_UNITS
+    return (
+        f"Observation @ {obs.timestamp}\n"
+        f"  pressure_raw : {obs.pressure_raw} {u['pressure_raw']}\n"
+        f"  pressure_qnh : {obs.pressure_qnh} {u['pressure_qnh']}\n"
+        f"  temperature  : {obs.temperature} {u['temperature']}\n"
+        f"  humidity     : {obs.humidity} {u['humidity']}\n"
+        f"  altitude     : {obs.altitude} {u['altitude']}"
+    )
+
+
+def sparkline(values: list[float]) -> str:
+    """Render a sequence of floats as a Unicode block-character sparkline.
+
+    Maps the min–max range of values onto the eight block characters
+    (▁▂▃▄▅▆▇█), so relative trends are visible at a glance.
+
+    Args:
+        values: Ordered sequence of numeric values to visualise.
+
+    Returns:
+        A string of Unicode block characters proportional to each value's
+        position in the min–max range. Returns an empty string if values is empty.
+    """
+    if not values:
+        return ""
+    lo, hi = min(values), max(values)
+    span = hi - lo or 1.0
+    return "".join(
+        SPARKLINE_CHARS[int((v - lo) / span * (len(SPARKLINE_CHARS) - 1))]
+        for v in values
+    )
+
+
+def trend_arrow(current: float, previous: float | None, threshold: float = 0.1) -> str:
+    """Return a Unicode arrow indicating the direction of change between two values.
+
+    Args:
+        current: The latest value.
+        previous: The preceding value, or None if no previous reading exists.
+        threshold: Minimum absolute delta required to show an up or down arrow.
+            Changes within ±threshold are shown as a right arrow (→). Defaults to 0.1.
+
+    Returns:
+        "↑" if current exceeds previous by more than threshold,
+        "↓" if current is below previous by more than threshold,
+        "→" if the change is within ±threshold,
+        " " (space) if previous is None.
+    """
+    if previous is None:
+        return " "
+    delta = current - previous
+    if delta > threshold:
+        return "↑"
+    if delta < -threshold:
+        return "↓"
+    return "→"
+
+
+def render_dashboard(observations: list[Observation]) -> None:
+    """Clear the terminal and render the full NowcastingCLI dashboard.
+
+    Displays a Rich table with one row per observation (time, raw pressure,
+    QNH pressure with trend arrow, temperature, relative humidity, and altitude),
+    followed by a panel showing the QNH sparkline, the current nowcast verdict,
+    and the reason string produced by assess_conditions().
+
+    Also emits an INFO log entry for the latest observation with pressure_qnh,
+    verdict, and reason as structured fields.
+
+    Args:
+        observations: Ordered list of Observation objects, earliest first.
+            Must contain at least one entry.
+    """
+    console.clear()
+
+    table = Table(box=box.SIMPLE_HEAD, show_header=True, header_style="bold cyan")
+    table.add_column("Time",          style="dim",     width=8)
+    table.add_column("Raw (hPa)",     justify="right", width=12)
+    table.add_column("QNH (hPa)",     justify="right", width=14)
+    table.add_column("Temp",          justify="right", width=8)
+    table.add_column("RH",            justify="right", width=8)
+    table.add_column("Alt",           justify="right", width=8)
+
+    for i, obs in enumerate(observations):
+        prev = observations[i - 1] if i > 0 else None
+        table.add_row(
+            obs.timestamp.strftime("%H:%M"),
+            f"{obs.pressure_raw:.1f}",
+            f"{obs.pressure_qnh:.1f} {trend_arrow(obs.pressure_qnh, prev.pressure_qnh if prev else None)}",
+            f"{obs.temperature:.0f}°C {trend_arrow(obs.temperature, prev.temperature if prev else None)}",
+            f"{obs.humidity:.0f}% {trend_arrow(obs.humidity, prev.humidity if prev else None)}",
+            f"{obs.altitude:.0f}m",
+        )
+
+    verdict, reason = assess_conditions(observations)
+    label, style    = VERDICT_STYLE[verdict]
+
+    # get the latest observation for logging context
+    obs = observations[-1]
+    logger.info("Observation recorded",
+            extra={"pressure_qnh": obs.pressure_qnh,
+                   "verdict": verdict,
+                   "reason": reason})
+
+    pressures = [o.pressure_qnh for o in observations]
+    spark     = sparkline(pressures)
+    if len(pressures) >= 2:
+        total_delta = pressures[-1] - pressures[0]
+        spark_line  = f"{spark}  ({total_delta:+.1f} hPa over session)"
+    else:
+        spark_line = spark or "—"
+
+    footer = Text()
+    footer.append("Pressure trend:  ", style="dim")
+    footer.append(spark_line + "\n\n")
+    footer.append("Nowcast:  ")
+    footer.append(label + "\n", style=style)
+    footer.append("Reason:   ", style="dim")
+    footer.append(reason)
+
+    console.print(table)
+    console.print(Panel(footer, title="[bold]NowcastingCLI v1.0[/bold]", border_style="blue"))

nowcastingcli/heuristics.py

@@ -0,0 +1,65 @@
+from .models import Observation
+
+# setup_logging() is called in main.py before this module is imported — handlers already registered.
+import logging
+logger = logging.getLogger(__name__)
+
+
+
+WORSENING = "worsening"
+STABLE    = "stable"
+IMPROVING = "improving"
+
+PRESSURE_FALL_THRESHOLD  = -1.0   # hPa — rapid drop signals worsening conditions
+HIGH_HUMIDITY_THRESHOLD  = 85.0   # %   — high humidity signals worsening conditions
+PRESSURE_RISE_THRESHOLD  =  1.0   # hPa — sustained rise signals improving conditions
+
+
+def assess_conditions(observations: list[Observation]) -> tuple[str, str]:
+    """Derive a nowcast verdict and human-readable reason from recent observations.
+
+    Compares the last two observations to detect rapid pressure falls or high
+    humidity (WORSENING), sustained pressure rises with falling humidity
+    (IMPROVING), or neither (STABLE). Decision thresholds are defined by the
+    module-level constants PRESSURE_FALL_THRESHOLD, PRESSURE_RISE_THRESHOLD,
+    and HIGH_HUMIDITY_THRESHOLD.
+
+    Args:
+        observations: Ordered list of Observation objects, earliest first.
+            At least two entries are required for a meaningful verdict.
+
+    Returns:
+        A tuple of (verdict, reason) where:
+            - verdict is one of the module constants WORSENING, STABLE, or IMPROVING.
+            - reason is a human-readable string explaining the verdict.
+        If fewer than two observations are provided, returns
+        (STABLE, "Insufficient data — enter at least one more reading").
+    """
+    if len(observations) < 2:
+        verdict = STABLE
+        reason  = "Insufficient data — enter at least one more reading"
+        return (verdict, reason)
+
+    current  = observations[-1]
+    previous = observations[-2]
+
+    pressure_delta = current.pressure_qnh - previous.pressure_qnh  # hPa
+
+    if pressure_delta < PRESSURE_FALL_THRESHOLD or current.humidity > HIGH_HUMIDITY_THRESHOLD:
+        reason_parts = []
+        if pressure_delta < PRESSURE_FALL_THRESHOLD:
+            reason_parts.append(f"Rapid pressure fall ({pressure_delta:+.1f} hPa)")
+        if current.humidity > HIGH_HUMIDITY_THRESHOLD:
+            reason_parts.append(f"High humidity ({current.humidity:.0f}%)")
+        verdict = WORSENING
+        reason  = " + ".join(reason_parts)
+        return (verdict, reason)
+
+    if pressure_delta > PRESSURE_RISE_THRESHOLD and current.humidity < previous.humidity:
+        verdict = IMPROVING
+        reason  = f"Pressure rising ({pressure_delta:+.1f} hPa), humidity falling"
+        return (verdict, reason)
+
+    verdict = STABLE
+    reason  = f"Pressure change within normal range ({pressure_delta:+.1f} hPa)"
+    return (verdict, reason)

nowcastingcli/logging_config.py

@@ -0,0 +1,64 @@
+# nowcastingcli/logging_config.py
+import logging.config
+
+# Schema consumed by logging.config.dictConfig() — see the stdlib "dictionary
+# schema" docs. Structure:
+#   version: must be 1 (only schema version defined by the stdlib).
+#   disable_existing_loggers: False, so loggers created via getLogger() before
+#     this config runs are kept instead of being silenced.
+#   formatters: name -> formatter spec.
+#     "()" is a special key: a dotted path to a callable/class to instantiate
+#     in place of the default logging.Formatter (used here for JsonFormatter).
+#   handlers: name -> handler spec.
+#     "class" is a dotted path to the handler class; all other keys are
+#     passed through as constructor kwargs. "formatter" references a key in
+#     formatters. "ext://..." resolves a dotted path to an existing object
+#     (e.g. sys.stderr) rather than instantiating one.
+#   loggers: name -> logger spec.
+#     "handlers" is a list of handler names above. "propagate": False stops
+#     records from bubbling up to the root logger. Child loggers created via
+#     getLogger(__name__) (e.g. "nowcastingcli.physics") inherit this config
+#     through the dotted-name hierarchy without their own entry.
+LOGGING_CONFIG = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "plain": {
+            "format": "%(asctime)s %(levelname)-8s %(name)s — %(message)s",
+            "datefmt": "%Y-%m-%dT%H:%M:%S",
+        },
+        "json": {
+            "()": "pythonjsonlogger.json.JsonFormatter",
+            "format": "%(asctime)s %(levelname)s %(name)s %(message)s",
+        },
+    },
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "level": "WARNING",        # only warnings+ to terminal
+            "formatter": "plain",
+            "stream": "ext://sys.stderr",
+        },
+        "file": {
+            "class": "logging.handlers.RotatingFileHandler",
+            "level": "DEBUG",          # everything to file
+            "formatter": "json",
+            "filename": "logs/nowcastingcli.log",
+            "maxBytes": 1_000_000,
+            "backupCount": 3,
+        },
+    },
+    "loggers": {
+        "nowcastingcli": {
+            "level": "DEBUG",
+            "handlers": ["console", "file"],
+            "propagate": False,        # don't double-log to root
+        },
+    },
+}
+
+
+def setup_logging() -> None:
+    import os
+    os.makedirs("logs", exist_ok=True)
+    logging.config.dictConfig(LOGGING_CONFIG)

nowcastingcli/main.py

@@ -0,0 +1,216 @@
+import argparse
+import csv
+from dataclasses import dataclass
+from datetime import datetime
+from rich.prompt import Prompt
+
+from .models import Observation
+from .physics import normalize_pressure
+from .display import render_dashboard, console
+from .heuristics import assess_conditions
+
+# Must be called before any getLogger() — wires up file+console handlers via dictConfig.
+from nowcastingcli.logging_config import setup_logging
+setup_logging()
+import logging
+logger = logging.getLogger(__name__)
+
+CSV_COLUMNS   = ["pressure_hpa", "temperature_c", "humidity_pct", "altitude_m"]
+PRESSURE_RANGE = (0.1,  1100.0)
+TEMP_RANGE     = (-60,    60.0)
+HUMIDITY_RANGE = (0.0,   100.0)
+ALTITUDE_RANGE = (-500, 5000.0)
+
+
+@dataclass
+class _InputRow:
+    pressure:    float
+    temperature: float
+    humidity:    float
+    altitude:    float
+
+
+def _parse_csv(path: str) -> list[_InputRow]:
+    """Read and validate observations from a CSV file.
+
+    Raises ValueError with a descriptive message on missing columns,
+    non-numeric values, or out-of-range fields.
+    """
+    rows: list[_InputRow] = []
+    with open(path, newline="") as f:
+        reader = csv.DictReader(f)
+
+        missing = [c for c in CSV_COLUMNS if c not in (reader.fieldnames or [])]
+        if missing:
+            raise ValueError(f"CSV missing columns: {missing}. Expected: {CSV_COLUMNS}")
+
+        for line_num, row in enumerate(reader, start=2):
+            try:
+                pressure    = float(row["pressure_hpa"])
+                temperature = float(row["temperature_c"])
+                humidity    = float(row["humidity_pct"])
+                altitude    = float(row["altitude_m"])
+            except ValueError as exc:
+                raise ValueError(f"Row {line_num}: non-numeric value — {exc}") from exc
+
+            _check_range("pressure",    pressure,    *PRESSURE_RANGE, line_num)
+            _check_range("temperature", temperature, *TEMP_RANGE,     line_num)
+            _check_range("humidity",    humidity,    *HUMIDITY_RANGE, line_num)
+            _check_range("altitude",    altitude,    *ALTITUDE_RANGE, line_num)
+
+            rows.append(_InputRow(pressure, temperature, humidity, altitude))
+
+    if not rows:
+        raise ValueError("CSV contains no data rows.")
+    return rows
+
+
+def _check_range(field: str, value: float, lo: float, hi: float, line_num: int) -> None:
+    if not (lo <= value <= hi):
+        raise ValueError(
+            f"Row {line_num}: {field} = {value} out of range [{lo}, {hi}]"
+        )
+
+
+def get_float(prompt: str, min_val: float, max_val: float) -> float:
+    """Prompt the user for a float within [min_val, max_val], retrying on invalid input."""
+    while True:
+        try:
+            value = float(Prompt.ask(prompt))
+            if min_val <= value <= max_val:
+                return value
+            console.print(f"[red]Value must be between {min_val} and {max_val}[/red]")
+        except ValueError:
+            console.print("[red]Please enter a valid number[/red]")
+
+
+def _record_observation(pressure_raw: float, temperature: float, humidity: float,
+                        altitude: float, observations: list[Observation],
+                        verdicts: list[str]) -> None:
+    """Normalize, store, render, and log one observation."""
+    logger.debug("Raw input received: p=%.1f T=%.1f RH=%.1f alt=%.1f",
+                 pressure_raw, temperature, humidity, altitude)
+
+    pressure_qnh = normalize_pressure(pressure_raw, altitude, temperature)
+    obs = Observation(
+        timestamp    = datetime.now(),
+        pressure_raw = pressure_raw,
+        pressure_qnh = pressure_qnh,
+        temperature  = temperature,
+        humidity     = humidity,
+        altitude     = altitude,
+    )
+    observations.append(obs)
+    render_dashboard(observations)
+
+    verdict, _ = assess_conditions(observations)
+    if verdicts and verdict != verdicts[-1]:
+        logger.warning("Verdict changed: %s → %s", verdicts[-1], verdict)
+    verdicts.append(verdict)
+
+
+def edit_observation(observations: list[Observation]) -> None:
+    """Let the user select a past observation by index and correct any field.
+
+    Re-derives pressure_qnh when pressure, temperature, or altitude is changed.
+    """
+    for i, obs in enumerate(observations, 1):
+        console.print(
+            f"  [{i}] {obs.timestamp.strftime('%H:%M')}  "
+            f"{obs.pressure_raw} hPa  {obs.temperature}°C  "
+            f"{obs.humidity}%  {obs.altitude}m"
+        )
+
+    raw_idx = Prompt.ask("Select observation to edit (number)")
+    try:
+        idx = int(raw_idx) - 1
+        if not (0 <= idx < len(observations)):
+            console.print("[red]Index out of range[/red]")
+            return
+    except ValueError:
+        console.print("[red]Please enter a number[/red]")
+        return
+
+    obs = observations[idx]
+    console.print("Field: [1] pressure  [2] temperature  [3] humidity  [4] altitude")
+    field = Prompt.ask("Field to edit")
+
+    if field == "1":
+        obs.pressure_raw = get_float("New pressure (hPa)", *PRESSURE_RANGE)
+    elif field == "2":
+        obs.temperature = get_float("New temperature (°C)", *TEMP_RANGE)
+    elif field == "3":
+        obs.humidity = get_float("New humidity (%)", *HUMIDITY_RANGE)
+    elif field == "4":
+        obs.altitude = get_float("New altitude (m)", *ALTITUDE_RANGE)
+    else:
+        console.print("[red]Invalid field choice[/red]")
+        return
+
+    if field in ("1", "2", "4"):
+        obs.pressure_qnh = normalize_pressure(obs.pressure_raw, obs.altitude, obs.temperature)
+
+    render_dashboard(observations)
+
+
+def run(input_file: str | None = None) -> None:
+    """Run the interactive NowcastingCLI session."""
+    observations: list[Observation] = []
+    verdicts:     list[str]         = []
+
+    console.print("[bold blue]NowcastingCLI v1.0[/bold blue] — type 'q' at any prompt to quit\n")
+    logger.info("NowcastingCLI started")
+
+    if input_file:
+        try:
+            rows = _parse_csv(input_file)
+        except (ValueError, OSError) as exc:
+            console.print(f"[red]Input file error: {exc}[/red]")
+            return
+        for row in rows:
+            _record_observation(row.pressure, row.temperature, row.humidity,
+                                row.altitude, observations, verdicts)
+    else:
+        while True:
+            try:
+                raw = Prompt.ask("\nEnter pressure (hPa), 'e' to edit a past reading, or 'q' to quit")
+                cmd = raw.strip().lower()
+                if cmd == "q":
+                    break
+                if cmd == "e":
+                    if not observations:
+                        console.print("[yellow]No observations to edit yet[/yellow]")
+                    else:
+                        edit_observation(observations)
+                    continue
+                try:
+                    pressure_raw = float(raw)
+                    if not (0.1 <= pressure_raw <= 1100.0):
+                        raise ValueError
+                except ValueError:
+                    console.print("[red]Value must be between 0.1 and 1100.0[/red]")
+                    continue
+                temperature = get_float("Temperature (°C)", *TEMP_RANGE)
+                humidity    = get_float("Relative Humidity (%)", *HUMIDITY_RANGE)
+                altitude    = get_float("GPS Altitude (m)", *ALTITUDE_RANGE)
+
+            except (KeyboardInterrupt, EOFError):
+                break
+
+            _record_observation(pressure_raw, temperature, humidity, altitude,
+                                observations, verdicts)
+
+    console.print("\n[dim]Session ended.[/dim]")
+
+
+def cli() -> None:
+    """CLI entry point — parses argv and delegates to run()."""
+    parser = argparse.ArgumentParser(description="NowcastingCLI — terminal weather nowcasting")
+    parser.add_argument("--input", metavar="FILE",
+                        help="CSV file with columns: pressure_hpa, temperature_c, humidity_pct, altitude_m")
+    args = parser.parse_args()
+    run(input_file=args.input)
+
+
+if __name__ == "__main__":
+    cli()

nowcastingcli/models.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass
+from datetime import datetime
+
+
+OBSERVATION_UNITS: dict[str, str] = {
+    "pressure_raw": "hPa",
+    "pressure_qnh": "hPa",
+    "temperature": "°C",
+    "humidity": "%",
+    "altitude": "m",
+}
+
+
+@dataclass
+class Observation:
+    """A single weather observation recorded at a station.
+
+    Attributes:
+        timestamp: Date and time the observation was recorded.
+        pressure_raw: Raw station pressure as measured by the sensor, in hPa.
+            Reflects actual atmospheric pressure at the station's altitude.
+        pressure_qnh: Station pressure normalised to sea level (QNH), in hPa.
+            Derived from pressure_raw via the barometric formula in physics.py.
+        temperature: Ambient air temperature at the station, in °C.
+        humidity: Relative humidity at the station, in %. Must be in [0, 100].
+        altitude: GPS altitude of the station above sea level, in m.
+
+    Raises:
+        ValueError: If humidity is outside [0, 100] or pressure_raw <= 0.
+    """
+
+    timestamp: datetime
+    pressure_raw: float      # as measured
+    pressure_qnh: float      # normalized to sea level
+    temperature: float
+    humidity: float
+    altitude: float
+
+    def __post_init__(self):
+        if not (0 <= self.humidity <= 100):
+            raise ValueError(f"humidity out of range: {self.humidity}")
+        if self.pressure_raw <= 0:
+            raise ValueError(f"invalid pressure: {self.pressure_raw}")
+

nowcastingcli/physics.py

@@ -0,0 +1,65 @@
+# setup_logging() is called in main.py before this module is imported — handlers already registered.
+import logging
+logger = logging.getLogger(__name__)
+
+
+# ISA (International Standard Atmosphere) constants used in the barometric formula.
+
+# Temperature lapse rate: the rate at which temperature drops with altitude
+# in the troposphere under standard conditions. Units: K/m (kelvin per metre).
+LAPSE_RATE_K_PER_M = 0.0065
+
+# Barometric exponent: encodes gravity (g=9.80665 m/s²), dry-air molar mass
+# (M=0.028964 kg/mol), and the universal gas constant (R=8.31446 J/mol·K)
+# as g*M / (R*L) = 9.80665*0.028964 / (8.31446*0.0065) ≈ 5.257. Dimensionless.
+BAROMETRIC_EXPONENT = 5.257
+
+# Offset to convert Celsius to Kelvin. Units: K.
+KELVIN_OFFSET = 273.15
+
+# Upper altitude limit of the ISA troposphere model. Accuracy degrades above
+# this altitude due to non-standard lapse rates and humidity effects. Units: m.
+MAX_ALTITUDE_M = 5000.0
+
+
+def normalize_pressure(pressure_hpa: float, altitude_m: float, temperature_c: float) -> float:
+    """Convert station pressure to QNH (sea-level equivalent) via the barometric formula.
+
+    Uses the hypsometric approximation valid in the ISA troposphere below ~5000 m:
+
+        P₀ = P_station × (1 − L·h / T₀) ^ −(g·M / R·L)
+
+    where:
+        - L = 0.0065 K/m  (ISA lapse rate, LAPSE_RATE_K_PER_M)
+        - T₀ = temperature_c + L·altitude_m + 273.15  (extrapolated sea-level temp, K)
+        - Exponent 5.257 = g·M / (R·L), encoding gravity (9.80665 m/s²),
+          dry-air molar mass (0.028964 kg/mol), and the gas constant (8.31446 J/mol·K)
+
+    Assumes a constant lapse rate, dry air, and hydrostatic equilibrium.
+    Accuracy degrades above 5000 m and in temperature-inversion conditions.
+
+    Reference: https://en.wikipedia.org/wiki/Barometric_formula
+
+    Args:
+        pressure_hpa: Raw station pressure in hectopascals (hPa). Must be > 0.
+        altitude_m: GPS altitude of the station above sea level in metres (m).
+            Must not exceed 5000 m (ISA troposphere model limit).
+        temperature_c: Ambient temperature at the station in degrees Celsius (°C).
+
+    Returns:
+        QNH pressure in hectopascals (hPa) — station pressure normalised to sea level.
+
+    Raises:
+        ValueError: If pressure_hpa <= 0 or altitude_m > 5000 m.
+    """
+    if pressure_hpa <= 0:
+        logger.error("Invalid pressure: %.2f hPa", pressure_hpa)
+        raise ValueError(f"pressure_hpa must be positive, got {pressure_hpa}")
+    if altitude_m > MAX_ALTITUDE_M:
+        logger.error("Altitude exceeds model limit: %.2f m", altitude_m)
+        raise ValueError(
+            f"altitude_m {altitude_m} exceeds model limit of {MAX_ALTITUDE_M} m"
+        )
+
+    t0 = temperature_c + LAPSE_RATE_K_PER_M * altitude_m + KELVIN_OFFSET
+    return pressure_hpa * (1 - (LAPSE_RATE_K_PER_M * altitude_m) / t0) ** -BAROMETRIC_EXPONENT

nowcastingcli-0.6.1.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: nowcastingcli
+Version: 0.6.1
+Summary: Terminal weather nowcasting dashboard
+Requires-Python: >=3.11
+Requires-Dist: rich>=13.0
+Requires-Dist: python-json-logger
+Provides-Extra: docs
+Requires-Dist: mkdocs<2.0,>=1.5; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: wheel; extra == "dev"

nowcastingcli-0.6.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+nowcastingcli/__init__.py,sha256=f9Zr_53mWU_TXeR36kI1hgnkb2G5ZvXnv8nQ4U46bfI,410
+nowcastingcli/display.py,sha256=jNHhN3CIWkeZ71nIm7zyJ9DuTSO2YeQLUIZYxAYIoH0,5883
+nowcastingcli/heuristics.py,sha256=HfTXWPUgb5VEFcGCf7mA7WjexItYIL6A6VDUI1pJG0E,2699
+nowcastingcli/logging_config.py,sha256=i6NlhMzlZXkaxNpDk72QREqS-Ei0B2K-BTghLW_6knw,2502
+nowcastingcli/main.py,sha256=l7qM0MpGo-rlTrq8dE2ApO4ho3lLop6bDz5f_esULkw,8056
+nowcastingcli/models.py,sha256=ZHmGhESltOj3I1sM5gTCPnAvf7RLODsIjd32Qh2lVNo,1462
+nowcastingcli/physics.py,sha256=a1EbtLS3m4FgDt08JAiV9hxSATpH9yyirOldxNlYODE,2898
+scripts/Init_observation.py,sha256=_U9hvua761pmZIae3rogboKrtoG-5lfhaGoW-EMIAFo,362
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_display.py,sha256=5rjlV7r2T82YFvuvzJP8AUgW6wZcePlEWfNSnIDodXs,9710
+tests/test_heuristics.py,sha256=DWdXro8CoxJjCCBJ6bGxmvxnW4hilQc_XoeN9IQeLqw,2706
+tests/test_main.py,sha256=KgaD7H1pc9Vg_M0WSBqfYi2sjxdhkZoOBkKTexmi7pk,20089
+tests/test_models.py,sha256=eDdktWwbfbJlzCvOWm7lhTLDQNBaX38pJ-keC6wJq0c,4131
+tests/test_physics.py,sha256=tmvKWUi8--r4xAszhr0tHVEZMV5ifK8lIS-1R1U7-So,4449
+nowcastingcli-0.6.1.dist-info/METADATA,sha256=eP6v3AAb0HZ0PULKKg2Y-ogJrD4QWJu_yYSSL0u6NHo,538
+nowcastingcli-0.6.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+nowcastingcli-0.6.1.dist-info/entry_points.txt,sha256=W93cb2M5EaMwxiMLaAuU3_cOsR7gl-l_QatKB4ee5b4,57
+nowcastingcli-0.6.1.dist-info/top_level.txt,sha256=mBII7Oqi3qo2IUGW4NM0lt906ymtSid45bVoi1d4coM,28
+nowcastingcli-0.6.1.dist-info/RECORD,,

nowcastingcli-0.6.1.dist-info/WHEEL

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

nowcastingcli-0.6.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nowcastingcli = nowcastingcli.main:cli