mostlyrightmd-weather 0.1.2__tar.gz

mostlyrightmd_weather-0.1.2/.gitignore

@@ -0,0 +1,68 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg
+*.egg-info/
+build/
+dist/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Testing / linting
+.pytest_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+
+# Local cache (tradewinds runtime cache lives in $HOME/.tradewinds/; this catches any test-time fixtures that leak)
+.tradewinds-cache/
+
+# Phase 4 CI-05 — drift watchdog populates tests/fixtures/drift/ from the
+# weekly cron. The scripts + README are tracked; the captured parquets
+# and the drift-report are not (rotation is the whole point — git history
+# isn't the storage layer for drift fixtures).
+tests/fixtures/drift/case_*.parquet
+tests/fixtures/drift/drift-report.md
+
+# uv — uv.lock IS committed for dev reproducibility across Lane F + Lane V (decision: lockfile-tracked for dev parity)
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+.claude/scheduled_tasks.lock
+
+# Planning artifacts — local GSD planning workspace; NOT for public consumption.
+# Untracked since the repo went public (Phase 13 W0 cleanup commit, 2026-05-25).
+# Operators keep these on disk for ongoing GSD workflow; nothing in `.planning/`
+# should be required to build or run the SDK.
+.planning/
+
+# Dev-only TODO scratchpad (replaced by GSD TODOS in .planning/)
+TODOS.md
+
+# TypeScript / pnpm workspace (packages-ts/)
+node_modules/
+coverage/
+.tsbuildinfo
+packages-ts/*/dist/
+packages-ts/*/coverage/
+# Note: top-level `dist/` and `build/` already covered by Python section above.
+
+# TS-W2 Plan 08 drift watchdog — output files are transient, not committed.
+packages-ts/meta/tests/parity/drift/*.json
+packages-ts/meta/tests/parity/drift-report.md
+.claude/

mostlyrightmd_weather-0.1.2/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: mostlyrightmd-weather
+Version: 0.1.2
+Summary: Weather data sources for mostlyright: AWC, IEM, GHCNh, NWS CLI. Direct public-API access; no hosted backend. Python module: `import mostlyright.weather`.
+Author-email: Robert Tarabcak <tarabcakr@gmail.com>
+License-Expression: MIT
+Keywords: awc,ghcnh,iem,metar,nws-cli,weather
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: filelock>=3.12
+Requires-Dist: httpx>=0.27
+Requires-Dist: jsonschema>=4.21
+Requires-Dist: mostlyrightmd<0.2,>=0.1.0
+Requires-Dist: pyarrow<24.0,>=17.0
+Requires-Dist: tzdata; sys_platform == 'win32'
+Provides-Extra: nwp
+Requires-Dist: cfgrib<1.0,>=0.9.15; extra == 'nwp'
+Requires-Dist: pandas<4.0,>=2.2; extra == 'nwp'
+Requires-Dist: scikit-learn<2.0,>=1.3; extra == 'nwp'
+Requires-Dist: xarray>=2024.0; extra == 'nwp'
+Provides-Extra: parquet
+Requires-Dist: pandas<4.0,>=2.2; extra == 'parquet'
+Provides-Extra: polars
+Requires-Dist: narwhals<2.0,>=1.20; extra == 'polars'
+Requires-Dist: pandas<4.0,>=2.2; extra == 'polars'
+Requires-Dist: polars<2.0,>=1.0; extra == 'polars'
+Requires-Dist: pyarrow<24.0,>=17.0; extra == 'polars'
+Description-Content-Type: text/markdown
+
+# mostlyrightmd-weather
+
+Weather data sources for `mostlyright`: AWC, IEM, GHCNh, NWS CLI.
+
+Direct public-API access. No hosted backend. Local parquet cache at `$HOME/.mostlyright/cache/`.
+
+See the workspace [README](../../README.md) and [CLAUDE.md](../../CLAUDE.md) for project rules.

mostlyrightmd_weather-0.1.2/README.md

@@ -0,0 +1,7 @@
+# mostlyrightmd-weather
+
+Weather data sources for `mostlyright`: AWC, IEM, GHCNh, NWS CLI.
+
+Direct public-API access. No hosted backend. Local parquet cache at `$HOME/.mostlyright/cache/`.
+
+See the workspace [README](../../README.md) and [CLAUDE.md](../../CLAUDE.md) for project rules.

mostlyrightmd_weather-0.1.2/pyproject.toml

@@ -0,0 +1,78 @@
+[project]
+name = "mostlyrightmd-weather"
+version = "0.1.2"
+description = "Weather data sources for mostlyright: AWC, IEM, GHCNh, NWS CLI. Direct public-API access; no hosted backend. Python module: `import mostlyright.weather`."
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "Robert Tarabcak", email = "tarabcakr@gmail.com" }]
+requires-python = ">=3.11"
+keywords = ["weather", "metar", "awc", "iem", "ghcnh", "nws-cli"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    # mostlyright (core) provides _internal._bounds, _internal._convert,
+    # _internal._http, _internal.models, _internal.exceptions — used by the
+    # parsers (_awc, _iem, _climate, _ghcnh) and fetchers under mostlyright.weather.
+    # Pinned to the matching alpha to prevent users from mixing core/weather
+    # releases across the parity gate (PKG-03).
+    "mostlyrightmd>=0.1.0,<0.2",
+    # Pinned to v0.14.1 mostlyright deps
+    "httpx>=0.27",
+    "jsonschema>=4.21",
+    "tzdata; sys_platform == 'win32'",
+    # Local parquet cache requires filelock for concurrent process safety
+    "filelock>=3.12",
+    # Codex P2 fix (Wave 1.4): pyarrow used at import time in mostlyright.weather.cache
+    # for cache I/O. Cannot live in `parquet` optional extra — default install would
+    # fail to import the cache module. Upper bound (PKG-06) keeps a future
+    # pyarrow ABI break from silently invalidating the parity-critical cache.
+    "pyarrow>=17.0,<24.0",
+]
+
+[project.optional-dependencies]
+# DataFrame return values (cache.py uses pyarrow directly; pandas only needed
+# for users who want to convert cache output to DataFrames). Upper bound
+# mirrors the core `parquet` extra so a fresh install cannot pull pandas 3.x
+# and silently drift the parity-critical DataFrame dtypes.
+parquet = [
+    "pandas>=2.2,<4.0",
+]
+# Phase 3.2: NWP live-fetch (HRRR/GFS/NBM) via NOAA Big Data Program.
+# `cfgrib` brings in `eccodes` + `eccodeslib` transitively, which ship
+# the binary GRIB2 codec as Python wheels (no system `apt install
+# eccodes-bin` / `brew install eccodes` required on Linux/macOS/Windows).
+# `xarray` is cfgrib's API surface; `scikit-learn` provides
+# BallTree(haversine) for nearest-grid-cell extraction.
+# Pandas is a transitive dep of the parquet extra above; included here
+# so a user who installs only `[nwp]` gets a usable DataFrame return.
+nwp = [
+    "cfgrib>=0.9.15,<1.0",
+    "xarray>=2024.0",
+    "scikit-learn>=1.3,<2.0",
+    "pandas>=2.2,<4.0",
+]
+# Phase 6 (POLARS-05): mirror mostlyrightmd[polars] so weather adapters
+# can return polars frames via the `backend="polars"` kwarg.
+# pandas required for the boundary shim's polars↔pandas conversion
+# (codex iter-3 P2 fix). pyarrow required by pl.from_pandas/to_pandas
+# for non-trivial dtypes (codex iter-5 P1 fix). pyarrow is already in
+# mostlyrightmd-weather runtime deps so this is a no-op for the install
+# resolver but keeps the extra's contract explicit.
+polars = [
+    "polars>=1.0,<2.0",
+    "narwhals>=1.20,<2.0",
+    "pandas>=2.2,<4.0",
+    "pyarrow>=17.0,<24.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mostlyright"]

mostlyrightmd_weather-0.1.2/src/mostlyright/weather/__init__.py

@@ -0,0 +1,36 @@
+"""mostlyright.weather — direct public-API access for AWC, IEM, GHCNh, NWS CLI.
+
+Local-first; no hosted backend; no API keys. Parsers are byte-faithful lifts
+from ``monorepo-v0.14.1``; HTTP fetchers and the parquet cache are net-new
+Sprint 0 code so the SDK can run without the v0.14.1 ingest service.
+
+Lift inventory (provenance for parity-critical code). Source SHA refers to
+the v0.14.1 release tag of ``Tarabcak/monorepo`` (commit
+``514fcdab227e845145ca32b989355647466231d9``).
+
+| Module                  | Source path                                            | Source SHA | Lift date  | Modifications                                                       |
+|-------------------------|--------------------------------------------------------|------------|------------|---------------------------------------------------------------------|
+| _awc.py                 | monorepo-v0.14.1/src/mostlyright/weather/_awc.py       | 514fcda    | 2026-05-21 | namespace rename only (imports point at ``mostlyright._internal``)   |
+| _iem.py                 | monorepo-v0.14.1/src/mostlyright/weather/_iem.py       | 514fcda    | 2026-05-21 | namespace rename only                                               |
+| _climate.py             | monorepo-v0.14.1/src/mostlyright/weather/_climate.py   | 514fcda    | 2026-05-21 | namespace rename only                                               |
+| _ghcnh.py               | monorepo-v0.14.1/src/mostlyright/weather/_ghcnh.py     | 514fcda    | 2026-05-21 | namespace rename only                                               |
+| _fetchers/__init__.py   | n/a (NEW)                                              | n/a        | 2026-05-21 | NEW (Sprint 0 Wave 1 Lane F) — fetcher package marker               |
+| _fetchers/awc.py        | n/a (NEW)                                              | n/a        | 2026-05-21 | NEW (Sprint 0 Wave 1 Lane F) — historical AWC range fetcher         |
+| _fetchers/iem_asos.py   | n/a (NEW)                                              | n/a        | 2026-05-21 | NEW (Sprint 0 Wave 1 Lane F) — monthly-chunked IEM ASOS METAR fetcher |
+| _fetchers/iem_cli.py    | n/a (NEW)                                              | n/a        | 2026-05-21 | NEW (Sprint 0 Wave 1 Lane F) — IEM CLI settlement-grade fetcher     |
+| _fetchers/ghcnh.py      | n/a (NEW)                                              | n/a        | 2026-05-21 | NEW (Sprint 0 Wave 1 Lane F) — per-year NCEI GHCNh PSV fetcher      |
+| cache.py                | n/a (NEW)                                              | n/a        | 2026-05-21 | NEW (Sprint 0 Wave 1 Lane F) — local parquet cache, filelock-guarded |
+
+``_bounds`` is imported from ``mostlyright._internal`` (lifted there from
+``monorepo-v0.14.1/src/mostlyright/_bounds.py``) — see the parallel lift
+inventory in ``mostlyright._internal.__init__``.
+
+Public surface kept stable for Vojtech's existing ``mostlyright==0.14.1``
+workflow: ``raw_metar`` is preserved on observation rows so MetPy re-parse
+keeps working without preprocessing in v0.1.0.
+"""
+
+from mostlyright.weather.obs import obs as obs  # re-export Phase 7 public surface
+
+__version__ = "0.1.0rc1"
+__all__ = ["__version__", "obs"]

mostlyrightmd_weather-0.1.2/src/mostlyright/weather/_awc.py

@@ -0,0 +1,347 @@
+"""AWC METAR transform — maps AWC JSON response to observation schema dict.
+
+This is THE shared transform. Both the SDK and ingest worker import it.
+Output dicts validate against specs/observation.json (additionalProperties: false).
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from datetime import UTC, datetime
+from typing import Any
+
+from mostlyright._internal._bounds import (
+    MAX_RAW_METAR_LEN,
+    MAX_VISIBILITY_MILES,
+    MAX_WX_CODES_LEN,
+    SKY_BASE_MAX_FT,
+    SLP_MAX_MB,
+    SLP_MIN_MB,
+    STATION_CODE_RE,
+    TEMP_MAX_C,
+    TEMP_MIN_C,
+    WIND_DIR_BOUNDS,
+    WIND_GUST_MAX,
+    WIND_SPEED_MAX,
+    bounded_float,
+    bounded_float_min,
+    bounded_int,
+)
+from mostlyright._internal._convert import celsius_to_fahrenheit, hpa_to_inhg
+
+
+def icao_to_station_code(icao: str) -> str:
+    """Strip leading K for 4-letter CONUS ICAO codes."""
+    upper = icao.strip().upper()
+    if upper.startswith("K") and len(upper) == 4:
+        return upper[1:]
+    return upper
+
+
+def parse_awc_visibility(vis: Any) -> float | None:
+    """Parse AWC visibility: '10+', '1/2', '2 1/4', '3/4', plain numbers.
+
+    Returns miles or None. Caps at 99.99.
+    """
+    if vis is None:
+        return None
+
+    s = str(vis)
+    if s == "" or s == "null":
+        return None
+
+    # "10+" -> 10
+    if s.endswith("+"):
+        try:
+            n = float(s[:-1])
+        except (ValueError, OverflowError):
+            return None
+        if not math.isfinite(n):
+            return None
+        return min(n, MAX_VISIBILITY_MILES)
+
+    # Mixed number: "1 1/2", "2 1/4"
+    if " " in s and "/" in s:
+        parts = s.split(" ", 1)
+        if len(parts) != 2:
+            return None
+        frac_parts = parts[1].split("/")
+        if len(frac_parts) != 2:
+            return None
+        try:
+            w = float(parts[0])
+            n = float(frac_parts[0])
+            d = float(frac_parts[1])
+        except (ValueError, OverflowError):
+            return None
+        if not (math.isfinite(w) and math.isfinite(n) and math.isfinite(d) and d != 0):
+            return None
+        return min(w + n / d, MAX_VISIBILITY_MILES)
+
+    # Simple fraction: "1/2", "1/4", "3/4", or "M1/4" (below-quarter-mile
+    # AWC/METAR convention — codex review W3A P2). The leading 'M' means
+    # "less than", which we represent as the same fractional value (the
+    # observation schema treats this as the visibility value, not a flag).
+    if "/" in s:
+        if s.startswith("M") or s.startswith("m"):
+            s = s[1:]
+        frac_parts = s.split("/")
+        if len(frac_parts) != 2:
+            return None
+        try:
+            n = float(frac_parts[0])
+            d = float(frac_parts[1])
+        except (ValueError, OverflowError):
+            return None
+        if not (math.isfinite(n) and math.isfinite(d) and d != 0):
+            return None
+        return min(n / d, MAX_VISIBILITY_MILES)
+
+    # Plain number
+    try:
+        n = float(s)
+    except (ValueError, OverflowError):
+        return None
+    if not math.isfinite(n):
+        return None
+    return min(n, MAX_VISIBILITY_MILES)
+
+
+def map_cloud_cover(cover: str | None) -> str | None:
+    """Map AWC cloud cover code to standard abbreviation."""
+    if cover is None:
+        return None
+    upper = cover.upper()
+    if upper in ("CLR", "SKC", "FEW", "SCT", "BKN", "OVC", "VV"):
+        return upper
+    if upper == "CAVOK":
+        return "CLR"
+    return None
+
+
+def _cloud_layer(layer: Any) -> tuple[str | None, int | None]:
+    """Extract cover and base from a cloud layer dict. Safe against non-dict entries."""
+    if not isinstance(layer, dict):
+        return None, None
+    base = bounded_int(_safe_int(layer.get("base")), 0, SKY_BASE_MAX_FT)
+    return map_cloud_cover(layer.get("cover")), base
+
+
+def _safe_int(v: Any) -> int | None:
+    """Convert to int. Returns None on bad input."""
+    if v is None:
+        return None
+    try:
+        f = float(v)
+        if not math.isfinite(f):
+            return None
+        return round(f)
+    except (ValueError, TypeError, OverflowError):
+        return None
+
+
+def _safe_float(v: Any) -> float | None:
+    """Convert to float. Returns None on bad input."""
+    if v is None:
+        return None
+    try:
+        f = float(v)
+        return f if math.isfinite(f) else None
+    except (ValueError, TypeError, OverflowError):
+        return None
+
+
+def _safe_precip(v: Any) -> float | None:
+    """Parse precipitation. Trace 'T' → 0.0, numeric passthrough, else None."""
+    if v is None:
+        return None
+    if isinstance(v, str) and v.strip().upper() == "T":
+        return 0.0
+    return _safe_float(v)
+
+
+_PK_WND_RE = re.compile(r"PK WND (\d{3})(\d{2,3})/(\d{4})")
+
+# T-group in METAR remarks: T{s}{SSS}{s}{DDD}
+# s=0 positive, s=1 negative. SSS/DDD = tenths of °C.
+# Example: T02560167 → 25.6°C / 16.7°C. T10390061 → -3.9°C / 6.1°C.
+_TGROUP_RE = re.compile(r"\bT([01])(\d{3})([01])(\d{3})\b")
+
+
+def _parse_peak_wind(
+    raw_metar: str | None,
+) -> tuple[int | None, int | None, str | None]:
+    """Parse PK WND from METAR remarks. Returns (dir, speed_kt, time_hhmm)."""
+    if not raw_metar:
+        return None, None, None
+    match = _PK_WND_RE.search(raw_metar)
+    if not match:
+        return None, None, None
+    direction = int(match.group(1))
+    speed = int(match.group(2))
+    time_hhmm = match.group(3)
+    if not (0 <= direction <= 360) or speed < 0:
+        return None, None, None
+    return direction, speed, time_hhmm
+
+
+def _parse_tgroup(raw_metar: str | None) -> tuple[float | None, float | None]:
+    """Parse T-group from METAR remarks for tenths-precision temperature.
+
+    ASOS stations always include T-group in remarks. Format: T{s}{SSS}{s}{DDD}
+    where s=0 positive, s=1 negative, SSS=temp tenths °C, DDD=dewpoint tenths °C.
+    Searches only the remarks section (after RMK) to avoid false positives.
+    Returns (temp_c, dewpoint_c) or (None, None) if not found.
+    """
+    if not raw_metar:
+        return None, None
+    # T-group is a remarks-only element — search only after RMK.
+    # No RMK section = no T-group. Do NOT fallback to full string
+    # to avoid false positives on body group patterns.
+    rmk_idx = raw_metar.find("RMK")
+    if rmk_idx < 0:
+        return None, None
+    match = _TGROUP_RE.search(raw_metar[rmk_idx:])
+    if not match:
+        return None, None
+    t_sign = -1 if match.group(1) == "1" else 1
+    t_val = int(match.group(2)) / 10.0 * t_sign
+    d_sign = -1 if match.group(3) == "1" else 1
+    d_val = int(match.group(4)) / 10.0 * d_sign
+    return t_val, d_val
+
+
+def awc_to_observation(m: dict[str, Any]) -> dict[str, Any] | None:
+    """Convert a parsed AWC METAR dict to an observation schema dict.
+
+    Returns None if icaoId or obsTime is invalid.
+    Output matches specs/observation.json (no extra fields).
+    """
+    icao_id = m.get("icaoId")
+    if not isinstance(icao_id, str) or not icao_id:
+        return None
+
+    obs_time = m.get("obsTime")
+    if not isinstance(obs_time, int | float):
+        return None
+
+    station_code = icao_to_station_code(icao_id)
+    if not STATION_CODE_RE.match(station_code):
+        return None
+
+    try:
+        dt = datetime.fromtimestamp(obs_time, tz=UTC)
+    except (OSError, OverflowError, ValueError):
+        return None
+    if not (1970 <= dt.year <= 2100):
+        return None
+    observed_at = dt.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    metar_type = (m.get("metarType") or "METAR").upper()
+    observation_type = "SPECI" if metar_type == "SPECI" else "METAR"
+
+    # Wind direction: handle "VRB" -> None, bounded [0, 360]
+    wdir: int | None = None
+    raw_wdir = m.get("wdir")
+    if raw_wdir is not None:
+        if isinstance(raw_wdir, int | float):
+            wdir = bounded_int(int(raw_wdir), *WIND_DIR_BOUNDS)
+        elif raw_wdir != "VRB":
+            try:
+                parsed = float(raw_wdir)
+                if math.isfinite(parsed):
+                    wdir = bounded_int(int(parsed), *WIND_DIR_BOUNDS)
+            except (ValueError, TypeError):
+                pass
+
+    wspd = bounded_int(_safe_int(m.get("wspd")), 0, WIND_SPEED_MAX)
+    wgst = bounded_int(_safe_int(m.get("wgst")), 0, WIND_GUST_MAX)
+
+    # Altimeter: AWC altim is in hPa, convert to inHg (no rounding)
+    altim = hpa_to_inhg(_safe_float(m.get("altim")))
+
+    # Sea-level pressure (already in mb/hPa)
+    slp = _safe_float(m.get("slp"))
+    if slp is not None and not (SLP_MIN_MB <= slp <= SLP_MAX_MB):
+        slp = None
+
+    # Cloud layers (safe against non-dict entries)
+    clouds = m.get("clouds") or []
+    cov1, base1 = _cloud_layer(clouds[0]) if len(clouds) > 0 else (None, None)
+    cov2, base2 = _cloud_layer(clouds[1]) if len(clouds) > 1 else (None, None)
+    cov3, base3 = _cloud_layer(clouds[2]) if len(clouds) > 2 else (None, None)
+    cov4, base4 = _cloud_layer(clouds[3]) if len(clouds) > 3 else (None, None)
+
+    # Raw METAR (truncate to 2048)
+    raw_ob = m.get("rawOb")
+    raw_metar: str | None = None
+    if isinstance(raw_ob, str):
+        raw_metar = raw_ob[:MAX_RAW_METAR_LEN]
+
+    # Weather codes
+    raw_wx = m.get("wxString")
+    weather_codes: str | None = None
+    if isinstance(raw_wx, str):
+        weather_codes = raw_wx[:MAX_WX_CODES_LEN]
+
+    # Temperature: T-group (tenths precision) overrides body group (whole degree).
+    # ASOS always includes T-group in remarks. If present, use it.
+    # Note: KNYC (Central Park) is NOT an ASOS station — may lack T-group,
+    # falling back to whole-degree body group temps from AWC.
+    temp_c = _safe_float(m.get("temp"))
+    dewp_c = _safe_float(m.get("dewp"))
+    tgroup_temp, tgroup_dewp = _parse_tgroup(raw_metar)
+    if tgroup_temp is not None:
+        temp_c = tgroup_temp
+    if tgroup_dewp is not None:
+        dewp_c = tgroup_dewp
+    temp_c = bounded_float(temp_c, TEMP_MIN_C, TEMP_MAX_C, field="temp_c")
+    dewp_c = bounded_float(dewp_c, TEMP_MIN_C, TEMP_MAX_C, field="dewpoint_c")
+    temp_f = celsius_to_fahrenheit(temp_c)
+    dewpoint_f = celsius_to_fahrenheit(dewp_c)
+
+    # Peak wind from METAR remarks (PK WND dddss/hhmm), bounded
+    pk_dir, pk_spd, pk_time = _parse_peak_wind(raw_metar)
+    pk_dir = bounded_int(pk_dir, *WIND_DIR_BOUNDS)
+    pk_spd = bounded_int(pk_spd, 0, WIND_GUST_MAX)
+
+    # Precipitation (AWC provides 'precip' field; 'T' = trace → 0.0, non-negative)
+    precip = bounded_float_min(_safe_precip(m.get("precip")), 0.0)
+
+    # QC field bitmask
+    qc_raw = m.get("qcField")
+    qc_field = _safe_int(qc_raw)
+
+    return {
+        "station_code": station_code,
+        "observed_at": observed_at,
+        "observation_type": observation_type,
+        "source": "awc",
+        "temp_c": temp_c,
+        "dewpoint_c": dewp_c,
+        "temp_f": temp_f,
+        "dewpoint_f": dewpoint_f,
+        "wind_dir_degrees": wdir,
+        "wind_speed_kt": wspd,
+        "wind_gust_kt": wgst,
+        "altimeter_inhg": altim,
+        "sea_level_pressure_mb": slp,
+        "sky_cover_1": cov1,
+        "sky_base_1_ft": base1,
+        "sky_cover_2": cov2,
+        "sky_base_2_ft": base2,
+        "sky_cover_3": cov3,
+        "sky_base_3_ft": base3,
+        "sky_cover_4": cov4,
+        "sky_base_4_ft": base4,
+        "visibility_miles": parse_awc_visibility(m.get("visib")),
+        "weather_codes": weather_codes,
+        "precip_1hr_inches": precip,
+        "peak_wind_gust_kt": pk_spd,
+        "peak_wind_dir": pk_dir,
+        "peak_wind_time": pk_time,
+        "snow_depth_inches": None,  # not available from AWC
+        "qc_field": qc_field,
+        "raw_metar": raw_metar,
+    }