PyStormTracker 0.3.2__tar.gz → 0.4.0__tar.gz

pystormtracker-0.4.0/.dockerignore

@@ -0,0 +1,16 @@
+.coverage
+.coverage.*
+.git
+.github
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.venv/
+.vscode/
+__pycache__/
+benchmark/
+data/test/
+docs/
+htmlcov/
+tests/
+worktrees/

pystormtracker-0.4.0/.github/workflows/ci.yml

@@ -0,0 +1,243 @@
+name: CI
+
+on:
+  pull_request:
+    paths:
+      - 'src/**'
+      - 'tests/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      - 'Dockerfile'
+      - '.github/workflows/ci.yml'
+  push:
+    branches:
+      - main
+      - release/**
+    tags:
+      - v*
+    paths:
+      - 'src/**'
+      - 'tests/**'
+      - 'pyproject.toml'
+      - 'uv.lock'
+      - 'Dockerfile'
+      - '.github/workflows/ci.yml'
+  release:
+    types: [published]
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref_name }}
+  cancel-in-progress: ${{ github.ref_type != 'tag' }}
+
+permissions:
+  contents: read
+
+jobs:
+  ruff-lint:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+      - name: Lint with Ruff
+        run: uv run ruff check .
+
+  ruff-format:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+      - name: Check formatting with Ruff
+        run: uv run ruff format --check .
+
+  mypy-typecheck:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install -y libopenmpi-dev
+      - name: Install dependencies
+        run: uv sync --frozen --group dev
+      - name: Type check with Mypy
+        run: uv run mypy src/ tests/
+
+  unit-tests:
+    name: unit-tests (Python ${{ matrix.python-version }}${{ matrix.min-deps && ', min-deps' || '' }})
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+        min-deps: [false]
+        include:
+          - python-version: "3.11"
+            min-deps: true
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          python-version: ${{ matrix.python-version }}
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install -y libopenmpi-dev
+      - name: Install dependencies
+        if: ${{ !matrix.min-deps }}
+        run: uv sync --frozen --group dev
+      - name: Install dependencies (min-deps)
+        if: ${{ matrix.min-deps }}
+        run: uv sync --group dev --resolution lowest-direct
+      - name: Run Unit Tests
+        if: matrix.python-version != '3.13' || matrix.min-deps
+        run: uv run pytest -vv
+
+      - name: Run Unit Tests with Coverage
+        if: matrix.python-version == '3.13' && !matrix.min-deps
+        run: uv run pytest -vv --cov=pystormtracker --cov-report=term-missing --cov-report=xml
+
+      - name: Upload coverage reports to Codecov
+        if: matrix.python-version == '3.13' && !matrix.min-deps
+        uses: codecov/codecov-action@v5
+        with:
+          files: ./coverage.xml
+          flags: unit
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+  integration-tests:
+    name: integration-tests (Python ${{ matrix.python-version }}, ${{ matrix.arch }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: amd64
+            os: ubuntu-24.04
+            python-version: "3.13"
+          - arch: arm64
+            os: ubuntu-24.04-arm
+            python-version: "3.13"
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          python-version: ${{ matrix.python-version }}
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install -y openmpi-bin libopenmpi-dev
+      - name: Install dependencies
+        run: uv sync --frozen --group dev
+      - name: Run Integration Tests
+        if: matrix.arch != 'amd64'
+        run: uv run pytest -vv tests/test_integration.py --run-integration
+
+      - name: Run Integration Tests with Coverage
+        if: matrix.arch == 'amd64'
+        run: uv run pytest -vv --cov=pystormtracker --cov-report=term-missing --cov-report=xml tests/test_integration.py --run-integration
+
+      - name: Upload coverage reports to Codecov
+        if: matrix.arch == 'amd64'
+        uses: codecov/codecov-action@v5
+        with:
+          files: ./coverage.xml
+          flags: integration
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+  docker-build:
+    name: docker-build
+    needs: [ruff-lint, ruff-format, mypy-typecheck, unit-tests, integration-tests]
+    # Only run on merges to main, release branches, tags, releases, or manual dispatch
+    if: |
+      github.event_name != 'pull_request' &&
+      (github.ref == 'refs/heads/main' ||
+       startsWith(github.ref, 'refs/heads/release/') ||
+       startsWith(github.ref, 'refs/tags/v') ||
+       github.event_name == 'release' ||
+       github.event_name == 'workflow_dispatch')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Build and load Docker image
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          push: false
+          load: true
+          platforms: linux/amd64
+          tags: "${{ github.repository_owner }}/${{ vars.DOCKER_IMAGE_NAME }}:${{ github.sha }}"
+          cache-from: type=gha,scope=docker-build
+          cache-to: type=gha,mode=max,scope=docker-build
+
+      - name: Smoke test Docker image
+        run: |
+          # Test CLI help
+          docker run --rm ${{ github.repository_owner }}/${{ vars.DOCKER_IMAGE_NAME }}:${{ github.sha }} --help
+          # Test library import
+          docker run --rm --entrypoint python ${{ github.repository_owner }}/${{ vars.DOCKER_IMAGE_NAME }}:${{ github.sha }} -c "import pystormtracker as pst; print('Import success')"
+
+      - name: Run Trivy vulnerability scanner
+        uses: aquasecurity/trivy-action@0.35.0
+        with:
+          image-ref: "${{ github.repository_owner }}/${{ vars.DOCKER_IMAGE_NAME }}:${{ github.sha }}"
+          format: "table"
+          exit-code: "0"
+          ignore-unfixed: true
+          vuln-type: "os,library"
+          severity: "CRITICAL,HIGH"
+
+  pypi-build:
+    name: pypi-build
+    needs: [ruff-lint, ruff-format, mypy-typecheck, unit-tests, integration-tests]
+    # Only run on merges to main, release branches, tags, releases, or manual dispatch
+    if: |
+      github.event_name != 'pull_request' &&
+      (github.ref == 'refs/heads/main' ||
+       startsWith(github.ref, 'refs/heads/release/') ||
+       startsWith(github.ref, 'refs/tags/v') ||
+       github.event_name == 'release' ||
+       github.event_name == 'workflow_dispatch')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+      - name: Build release distributions
+        run: uv build --wheel --sdist

pystormtracker-0.4.0/.github/workflows/docker-publish.yml

@@ -0,0 +1,119 @@
+name: Docker Publish
+
+on:
+  workflow_run:
+    workflows: ["CI"]
+    types: [completed]
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  # Publish to ORG on release, else to OWNER (personal) for merge to main/manual
+  DOCKER_HUB_REPO: docker.io/${{ (github.event_name == 'release' || (github.event_name == 'workflow_run' && github.event.workflow_run.event == 'release')) && vars.DOCKER_ORG_NAME || github.repository_owner }}/${{ vars.DOCKER_IMAGE_NAME }}
+  GHCR_REPO: ghcr.io/${{ (github.event_name == 'release' || (github.event_name == 'workflow_run' && github.event.workflow_run.event == 'release')) && vars.DOCKER_ORG_NAME || github.repository_owner }}/${{ vars.DOCKER_IMAGE_NAME }}
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    # Only run if CI succeeded (for workflow_run) or if it's a manual trigger.
+    # Added head_repository check for security in trusted context.
+    if: |
+      (github.event_name == 'workflow_run' && 
+       github.event.workflow_run.conclusion == 'success' && 
+       github.event.workflow_run.head_repository.full_name == github.repository &&
+       (github.event.workflow_run.head_branch == 'main' || github.event.workflow_run.event == 'release')) ||
+      github.event_name == 'workflow_dispatch'
+    permissions:
+      actions: read
+      contents: write
+      packages: write
+      id-token: write
+      attestations: write
+      artifact-metadata: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event.workflow_run.head_sha || github.ref }}
+          fetch-depth: 0
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v4
+        with:
+          username: ${{ vars.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+      - name: Log in to GHCR
+        uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GHCR_PAT }}
+
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@v6
+        with:
+          images: |
+            ${{ env.DOCKER_HUB_REPO }}
+            ${{ env.GHCR_REPO }}
+          # Fix: Tell the metadata action the real ref, otherwise it defaults to 'main'
+          ref: ${{ github.event.workflow_run.head_branch || github.ref }}
+          tags: |
+            # Tag with 'edge' only for main branch builds
+            type=edge,branch=main,priority=700
+            # Semver tags for releases (includes 'latest')
+            type=semver,pattern=latest,priority=1000
+            type=semver,pattern={{version}},priority=900
+            type=semver,pattern={{major}}.{{minor}},priority=900
+            type=semver,pattern={{major}},enable=${{ !startsWith(github.ref_name, 'v0') }},priority=900
+            # Branch tag for all branches except main
+            type=ref,event=branch,enable=${{ github.ref_name != 'main' }},priority=600
+            # Always tag with short SHA
+            type=sha,format=short,prefix=,priority=100
+
+      - name: Build and push Docker image
+        id: push
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          push: true
+          provenance: false
+          sbom: false
+          platforms: linux/amd64,linux/arm64
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha,scope=docker-build
+          cache-to: type=gha,mode=max,scope=docker-build
+
+      - name: Attest Provenance (Docker Hub)
+        uses: actions/attest@v4
+        with:
+          subject-name: ${{ env.DOCKER_HUB_REPO }}
+          subject-digest: ${{ steps.push.outputs.digest }}
+          push-to-registry: true
+
+      - name: Generate SBOM
+        uses: anchore/sbom-action@v0
+        with:
+          path: ./
+          artifact-name: sbom.cyclonedx.json
+          output-file: sbom.cyclonedx.json
+          format: cyclonedx-json
+
+      - name: Attest SBOM (Docker Hub)
+        uses: actions/attest@v4
+        with:
+          subject-name: ${{ env.DOCKER_HUB_REPO }}
+          subject-digest: ${{ steps.push.outputs.digest }}
+          sbom-path: 'sbom.cyclonedx.json'
+          push-to-registry: true

{pystormtracker-0.3.2 → pystormtracker-0.4.0}/.github/workflows/python-publish.yml

@@ -4,8 +4,9 @@
 name: Upload Python Package
 
 on:
-  release:
-    types: [published]
+  workflow_run:
+    workflows: ["CI"]
+    types: [completed]
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -17,6 +18,13 @@ permissions:
 jobs:
   release-build:
     runs-on: ubuntu-latest
+    # Only run if CI succeeded AND it was a release event.
+    # Added head_repository check for security.
+    if: |
+      github.event_name == 'workflow_run' && 
+      github.event.workflow_run.conclusion == 'success' && 
+      github.event.workflow_run.event == 'release' &&
+      github.event.workflow_run.head_repository.full_name == github.repository
     permissions:
       contents: read
       id-token: write
@@ -25,6 +33,7 @@ jobs:
     steps:
       - uses: actions/checkout@v6
         with:
+          ref: ${{ github.event.workflow_run.head_sha }}
           fetch-depth: 0
 
       - name: Set up uv
@@ -64,7 +73,8 @@ jobs:
         id: get_version
         run: |
           # Strips 'v' prefix from tag_name (e.g. v0.2.1 -> 0.2.1)
-          VERSION=${{ github.event.release.tag_name }}
+          # In workflow_run for a release, head_branch contains the tag name.
+          VERSION=${{ github.event.workflow_run.head_branch }}
           echo "version=${VERSION#v}" >> $GITHUB_OUTPUT
 
       - name: Retrieve release distributions

pystormtracker-0.4.0/.gitignore

@@ -0,0 +1,40 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*.so
+
+# Python Environments & Caches
+.venv/
+env/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.cache/
+
+# Distribution / packaging
+build/
+dist/
+sdist/
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+coverage.xml
+
+# Sphinx documentation
+docs/_build/
+
+# IPython intermediate checkpoints
+.ipynb_checkpoints
+
+# Data and Track files
+*.nc
+*.txt
+!data/test/tracks/*.txt
+*.pickle
+
+# IDE and Project Tooling
+.vscode/
+worktrees/

pystormtracker-0.4.0/.python-version

@@ -0,0 +1 @@
+3.13

pystormtracker-0.4.0/ARCHITECTURE.md

@@ -0,0 +1,97 @@
+# PyStormTracker Architecture
+
+This document describes the modern, high-performance architecture of PyStormTracker, detailing how it leverages vectorization and decoupled components to process massive climate datasets efficiently.
+
+## 1. High-Level Design Philosophy
+
+PyStormTracker is built for scale and extensibility. The architecture is centered around three core principles:
+1.  **Unified API (Tracker Protocol):** A structural interface that allows the CLI and Python API to support multiple tracking algorithms (e.g., `SimpleTracker`, `HodgesTracker`) interchangeably.
+2.  **Centralized Threshold Management:** The `SimpleDetector` is responsible for managing variable-specific detection thresholds (e.g., `1e-4` for vorticity), ensuring consistent behavior across different parallel backends.
+3.  **Vectorization & JIT:** Heavy mathematical operations are offloaded to **Numba** JIT-compiled kernels and **NumPy** broadcasting, bypassing Python's loop overhead and Global Interpreter Lock (GIL).
+4.  **Hybrid Parallelism:** The architecture parallelizes the computationally intensive **Detection** phase while centralizing the **Linking** phase to ensure perfect serial-parallel consistency.
+
+---
+
+## 2. Modern Core Components
+
+### 2.1 Array-Backed Data Models (`Tracks`, `Track`, `Center`)
+The data models utilize a contiguous memory paradigm:
+*   **`Tracks`**: The central container holding contiguous 1D NumPy arrays for `track_ids`, `times`, `lats`, `lons`, and a dictionary of scientific variables.
+*   **`Track`**: A lightweight "view" into the `Tracks` arrays for a specific ID.
+*   **`Center`**: A simple dataclass used strictly for iteration or final data export.
+
+**Benefits:** By avoiding the creation of millions of Python objects, memory usage is minimized, and data serialization between parallel processes is nearly instantaneous. Raw NumPy arrays also enable extremely fast distance calculations via C-level broadcasting.
+
+### 2.2 Shared DataLoader
+Data loading is encapsulated in a dedicated `DataLoader` class (`io/loader.py`). This component handles:
+*   **Format Abstraction**: Seamlessly detects and opens NetCDF (via `h5netcdf` or `netcdf4`) and GRIB (via `cfgrib`) files.
+*   **Variable Mapping**: Automatically maps common variable aliases (e.g., `msl`/`slp`, `vo`/`rv`) and coordinate names (`latitude`/`lat`), allowing the same tracking logic to work across different data providers.
+*   **Contiguous I/O**: Performs single-block contiguous reads from disk, bypassing HDF5 lock contention.
+
+### 2.3 Vectorized Linker (`SimpleLinker`)
+Trajectory construction uses NumPy broadcasting to calculate Haversine distance matrices between existing track tails and new storm centers. By sorting points spatially before matching, the Linker ensures deterministic, greedy nearest-neighbor linking.
+
+### 2.4 Parallel Pipeline (Gather-then-Link)
+To ensure that parallel results are bit-wise identical to serial runs, PyStormTracker uses a hybrid parallel strategy:
+1.  **Parallel Detection**: Assigned time chunks are distributed across Dask or MPI workers. Each worker runs Numba kernels to find centers and returns raw coordinate arrays.
+2.  **Centralized Linking**: The main process gathers the raw detections from all workers and performs a single sequential link. 
+
+**Why this works:** In storm tracking, the **Detection** phase (finding local extrema in 3D grids) consumes >95% of the runtime. The **Linking** phase (connecting coordinate lists) is extremely fast once vectorized. Centralizing the link eliminates the complex "merging" bugs found in tree-reduction strategies while maintaining near-perfect parallel scaling.
+
+---
+
+## 3. The `Tracker` Protocol
+
+The `Tracker` Protocol (defined in `src/pystormtracker/models/tracker.py`) provides a standardized interface for all tracking algorithms:
+
+```python
+import pystormtracker as pst
+
+# Instantiate any compliant tracker
+tracker = pst.SimpleTracker()
+
+# Standardized .track() method
+tracks = tracker.track(
+    infile="era5_msl.nc", 
+    varname="msl", 
+    start_time="2025-01-01",
+    backend="dask"
+)
+
+# Standardized export
+tracks.write("output.txt", format="imilast")
+```
+
+---
+
+## 4. Future Architectural Direction
+
+To further optimize scalability and memory efficiency for native-resolution climate datasets (e.g., 0.25° ERA5), the architecture is evolving towards deeper integration with the scientific Python ecosystem:
+
+*   **Idiomatic Xarray (`apply_ufunc`):** Transitioning away from custom MPI/Dask chunking in favor of Xarray's native `apply_ufunc(..., dask="parallelized")`. This delegates chunk management and distributed execution entirely to Xarray/Dask, reducing custom orchestration code.
+*   **Lazy Evaluation & Thread Topology:** Shifting from eager chunk-loading to lazy, frame-by-frame memory access to eliminate out-of-memory risks on large domains. Concurrently, strictly pinning Numba thread topologies to prevent CPU oversubscription in multi-process backends.
+*   **Tree-based Linking:** Upgrading the current NumPy-broadcasting linker to utilize C-level tree structures (e.g., `scipy.spatial.cKDTree`), breaking the $O(N^2)$ scaling barrier for extremely long or dense trajectory sequences.
+
+For more details on specific planned implementations, see the [Roadmap](ROADMAP.md).
+
+---
+
+## 5. Performance Benchmarks
+
+To quantify the efficiency gains of the modern array-backed JIT architecture, a comprehensive performance comparison was conducted between the legacy object-oriented system (`v0.3.3`) and the current implementation.
+
+Detailed execution timings (breaking down Detection, Linking, Export, and I/O Overhead) across Serial, Dask, and MPI backends for both standard and high-resolution ERA5 datasets are available in the [Benchmark Report](benchmark/BENCHMARK.md).
+
+---
+
+## Appendix: Evolution from Legacy Architecture
+
+The current architecture represents a fundamental shift from the legacy nested-object design used in earlier versions.
+
+| Feature | Legacy Architecture (v0.3.x and earlier) | Modern Architecture (v0.4.0+) |
+| :--- | :--- | :--- |
+| **Data Storage** | Nested lists of `Center` and `Track` objects. | Flat, C-contiguous NumPy arrays. |
+| **Parallelism** | Threads (bottlenecked by GIL). | Processes/MPI (true concurrent I/O). |
+| **Linking Strategy** | Tree-reduction (prone to boundary splits). | Parallel Detect + Centralized Link (perfect matching). |
+| **Linker** | $O(N^2)$ nested Python loops. | Vectorized NumPy matrix broadcasting. |
+| **I/O** | Many small lazy-loaded chunks. | Contiguous shared `DataLoader`. |

{pystormtracker-0.3.2 → pystormtracker-0.4.0}/CITATION.cff

@@ -1,5 +1,5 @@
 cff-version: 1.2.0
-title: PyStormTracker
+title: mwyau/PyStormTracker
 message: "If you use this software, please cite it as below."
 type: software
 authors:
@@ -12,15 +12,15 @@ identifiers:
     value: 10.5281/zenodo.18764813
 repository-code: 'https://github.com/mwyau/PyStormTracker'
 url: 'https://pystormtracker.readthedocs.io/'
-abstract: A Parallel Object-Oriented Cyclone Tracker in Python
+abstract: A High-Performance Cyclone Tracker in Python
 keywords:
   - cyclone tracking
   - climate variability
   - dask
   - mpi
 license: BSD-3-Clause
-version: 0.3.2
-date-released: '2026-03-09'
+version: 0.4.0
+date-released: '2026-03-10'
 preferred-citation:
   type: article
   authors:

{pystormtracker-0.3.2 → pystormtracker-0.4.0}/Dockerfile

@@ -1,5 +1,5 @@
 # --- Build Stage ---
-FROM python:3.14-slim AS builder
+FROM python:3.13-slim AS builder
 
 # Prevent uv from creating a virtualenv that might be hard to move
 ENV UV_COMPILE_BYTECODE=1 \
@@ -8,43 +8,31 @@ ENV UV_COMPILE_BYTECODE=1 \
 
 WORKDIR /app
 
-# Install build dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libeccodes-dev \
-    gcc \
-    libc6-dev \
-    && rm -rf /var/lib/apt/lists/*
-
 # Install uv
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
 
 # 1. Copy only dependency files for better layer caching.
-# This ensures that we only re-download dependencies if these files change.
 COPY pyproject.toml uv.lock ./
 
 # 2. Install third-party dependencies first (including grib extra).
-# --no-install-workspace allows us to install dependencies without the project source yet.
-RUN uv sync --frozen --no-dev --no-install-workspace --extra grib
+# Use cache mount for uv to persist downloads and build artifacts.
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev --no-install-workspace --extra grib --no-editable
 
 # 3. Copy only necessary source files for the final installation step.
 COPY src/ ./src/
 COPY README.md ./
 
 # 4. Final installation of the project package itself.
-# This step is very fast because the heavy dependencies are already cached.
-RUN uv sync --frozen --no-dev --extra grib
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev --extra grib --no-editable
 
 
 # --- Runtime Stage ---
-FROM python:3.14-slim
+FROM python:3.13-slim
 
 WORKDIR /app
 
-# Install ONLY the runtime shared libraries
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libeccodes0 \
-    && rm -rf /var/lib/apt/lists/*
-
 # Create data directory for mounting
 RUN mkdir /data && chmod 777 /data