tangram-weather 0.2.1__py3-none-any.whl

tangram_weather/WindFieldLayer.vue

@@ -0,0 +1,177 @@
+<template>
+  <div class="wind-altitude-control" @mousedown.stop @touchstart.stop>
+    <label for="hpa-slider">{{ isobaric }}hPa | FL{{ FL }}</label>
+    <input
+      id="hpa-slider"
+      v-model="isobaric"
+      type="range"
+      min="100"
+      max="1000"
+      step="50"
+      @input="updateLabel"
+      @change="updateValue"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, watch, inject, onUnmounted, onMounted } from "vue";
+import type { TangramApi, Disposable } from "@open-aviation/tangram-core/api";
+import { ParticleLayer, ImageType } from "weatherlayers-gl";
+
+const tangramApi = inject<TangramApi>("tangramApi");
+if (!tangramApi) {
+  throw new Error("assert: tangram api not provided");
+}
+
+const isobaric = ref(300);
+const FL = ref(300);
+const layerDisposable = ref<Disposable | null>(null);
+
+const convertHpaToFlightLevel = (hpa: number) => {
+  const P0 = 1013.25;
+  const T0 = 288.15;
+  const L = 0.0065;
+  const g = 9.80665;
+  const R = 287.05;
+  const H_TROP = 11000;
+
+  let altitude;
+  if (hpa > 226.32) {
+    altitude = (T0 / L) * (1 - Math.pow(hpa / P0, (L * R) / g));
+  } else {
+    const T_TROP = T0 - L * H_TROP;
+    const P_TROP = P0 * Math.pow(T_TROP / T0, g / (L * R));
+    altitude = H_TROP + ((T_TROP * R) / g) * Math.log(P_TROP / hpa);
+  }
+  return Math.round((altitude * 3.28084) / 1000) * 10;
+};
+
+const updateLabel = () => {
+  FL.value = convertHpaToFlightLevel(isobaric.value);
+};
+
+const updateValue = () => {
+  fetchAndDisplay();
+};
+
+async function loadTextureDataFromUri(
+  uri: string
+): Promise<{ data: Uint8ClampedArray; width: number; height: number }> {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      const canvas = document.createElement("canvas");
+      canvas.width = img.width;
+      canvas.height = img.height;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        return reject(new Error("Could not get 2d context from canvas"));
+      }
+      ctx.drawImage(img, 0, 0);
+      const imageData = ctx.getImageData(0, 0, img.width, img.height);
+      resolve({
+        data: imageData.data,
+        width: imageData.width,
+        height: imageData.height
+      });
+    };
+    img.onerror = err => {
+      reject(err);
+    };
+    img.src = uri;
+  });
+}
+
+const fetchAndDisplay = async () => {
+  if (!tangramApi.map.isReady.value) return;
+
+  if (layerDisposable.value) {
+    layerDisposable.value.dispose();
+    layerDisposable.value = null;
+  }
+
+  try {
+    const response = await fetch(`/weather/wind?isobaric=${isobaric.value}`);
+    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+    const { imageDataUri, bounds, imageUnscale } = await response.json();
+
+    const textureData = await loadTextureDataFromUri(imageDataUri);
+
+    const windPalette: [number, [number, number, number]][] = [
+      [0, [37, 99, 235]],
+      [10, [65, 171, 93]],
+      [20, [253, 174, 97]],
+      [30, [244, 109, 67]],
+      [40, [215, 25, 28]],
+      [50, [128, 0, 38]]
+    ];
+
+    const windLayer = new ParticleLayer({
+      id: "wind-field-layer",
+      image: textureData,
+      imageType: ImageType.VECTOR,
+      imageUnscale: imageUnscale,
+      bounds: bounds,
+
+      numParticles: 1500,
+      maxAge: 15,
+      speedFactor: 20,
+      width: 1,
+      palette: windPalette,
+      animate: true
+    });
+
+    layerDisposable.value = tangramApi.map.addLayer(windLayer);
+  } catch (error) {
+    console.error("Failed to fetch or display wind data:", error);
+  }
+};
+
+watch(
+  tangramApi.map.isReady,
+  isReady => {
+    if (isReady) {
+      fetchAndDisplay();
+    }
+  },
+  { immediate: true }
+);
+
+onMounted(() => {
+  FL.value = convertHpaToFlightLevel(isobaric.value);
+});
+
+onUnmounted(() => {
+  if (layerDisposable.value) {
+    layerDisposable.value.dispose();
+    layerDisposable.value = null;
+  }
+});
+</script>
+
+<style scoped>
+.wind-altitude-control {
+  position: absolute;
+  bottom: 20px;
+  right: 70px;
+  background: rgba(255, 255, 255, 0.8);
+  padding: 10px;
+  border-radius: 5px;
+  z-index: 1000;
+}
+
+.wind-altitude-control label {
+  font-family: "B612", sans-serif;
+  font-size: 12px;
+}
+
+input[type="range"] {
+  cursor: pointer;
+  width: 100%;
+  margin-top: 5px;
+  background: #bab0ac;
+  height: 2px;
+  border-radius: 5px;
+}
+</style>

tangram_weather/__init__.py

@@ -0,0 +1,79 @@
+import base64
+import io
+import logging
+
+import numpy as np
+import pandas as pd
+import tangram_core
+from fastapi import APIRouter
+from fastapi.responses import ORJSONResponse
+from PIL import Image
+
+from .arpege import latest_data as latest_arpege_data
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(
+    prefix="/weather",
+    tags=["weather"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@router.get("/")
+async def get_weather() -> dict[str, str]:
+    return {"message": "This is the weather plugin response"}
+
+
+@router.get("/wind")
+async def wind(
+    isobaric: int, backend_state: tangram_core.InjectBackendState
+) -> ORJSONResponse:
+    logger.info("fetching wind data for %s", isobaric)
+
+    now = pd.Timestamp.now(tz="UTC").floor("1h")
+    ds = await latest_arpege_data(backend_state.http_client, now)
+    res = ds.sel(isobaricInhPa=isobaric, time=now.tz_convert(None))[["u", "v"]]
+
+    u_attrs = res.data_vars["u"].attrs
+
+    bounds = [
+        u_attrs["GRIB_longitudeOfFirstGridPointInDegrees"],
+        u_attrs["GRIB_latitudeOfLastGridPointInDegrees"],
+        u_attrs["GRIB_longitudeOfLastGridPointInDegrees"],
+        u_attrs["GRIB_latitudeOfFirstGridPointInDegrees"],
+    ]
+
+    u_data = res["u"].values
+    v_data = res["v"].values
+
+    valid_data_mask = ~np.isnan(u_data)
+
+    min_val, max_val = -70.0, 70.0
+    image_unscale = [min_val, max_val]
+    value_range = max_val - min_val
+
+    u_scaled = (np.nan_to_num(u_data, nan=0.0) - min_val) / value_range * 255
+    v_scaled = (np.nan_to_num(v_data, nan=0.0) - min_val) / value_range * 255
+
+    rgba_data = np.zeros((*u_data.shape, 4), dtype=np.uint8)
+    rgba_data[..., 0] = u_scaled.astype(np.uint8)
+    rgba_data[..., 1] = v_scaled.astype(np.uint8)
+    rgba_data[..., 3] = np.where(valid_data_mask, 255, 0)
+
+    image = Image.fromarray(rgba_data, "RGBA")
+    buffer = io.BytesIO()
+    image.save(buffer, format="PNG")
+    img_str = base64.b64encode(buffer.getvalue()).decode("utf-8")
+    image_data_uri = f"data:image/png;base64,{img_str}"
+
+    response_content = {
+        "imageDataUri": image_data_uri,
+        "bounds": bounds,
+        "imageUnscale": image_unscale,
+    }
+
+    return ORJSONResponse(content=response_content)
+
+
+plugin = tangram_core.Plugin(frontend_path="dist-frontend", routers=[router])

tangram_weather/arpege.py

@@ -0,0 +1,133 @@
+import asyncio
+import logging
+import tempfile
+from pathlib import Path
+from typing import Literal
+
+import httpx
+import pandas as pd
+import xarray as xr
+from tqdm.auto import tqdm
+
+bare_url = "https://object.data.gouv.fr/meteofrance-pnt/pnt/"
+
+# fmt:off
+DEFAULT_LEVELS_37 = [
+    100, 125, 150, 175, 200, 225, 250, 300, 350, 400, 450,
+    500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000,
+]
+DEFAULT_IP1_FEATURES = ['u', 'v', 't', 'r']
+# fmt:on
+
+tempdir = Path(tempfile.gettempdir())
+log = logging.getLogger(__name__)
+
+
+async def download_with_progress(
+    client: httpx.AsyncClient, url: str, file: Path
+) -> None:
+    try:
+        async with client.stream("GET", url) as r:
+            if r.status_code != 200:
+                raise httpx.HTTPStatusError(
+                    f"Error downloading data from {url}", request=r.request, response=r
+                )
+
+            total_size = int(r.headers.get("Content-Length", 0))
+            with file.open("wb") as buffer:
+                with tqdm(
+                    total=total_size,
+                    unit="B",
+                    unit_scale=True,
+                    desc=url.split("/")[-1],
+                ) as progress_bar:
+                    first_chunk = True
+                    async for chunk in r.aiter_bytes():
+                        if first_chunk and chunk.startswith(b"<?xml"):
+                            raise RuntimeError(
+                                f"Error downloading data from {url}. "
+                                "Check if the requested data is available."
+                            )
+                        first_chunk = False
+                        await asyncio.to_thread(buffer.write, chunk)
+                        progress_bar.update(len(chunk))
+    except (httpx.RequestError, RuntimeError) as e:
+        if file.exists():
+            file.unlink()
+        raise e
+
+
+async def latest_data(
+    client: httpx.AsyncClient,
+    hour: pd.Timestamp,
+    model: str = "ARPEGE",
+    resolution: Literal["025", "01"] = "025",
+    package: Literal["SP1", "SP2", "IP1", "IP2", "IP3", "IP4", "HP1"] = "IP1",
+    time_range: Literal[
+        "000H024H",  # on the 0.25 degree grid
+        "025H048H",  # on the 0.25 degree grid
+        "049H072H",  # on the 0.25 degree grid
+        "073H102H",  # on the 0.25 degree grid
+        "000H012H",  # on the 0.1 degree grid
+        "013H024H",  # on the 0.1 degree grid
+        "025H036H",  # on the 0.1 degree grid
+        "037H048H",  # on the 0.1 degree grid
+        "049H060H",  # on the 0.1 degree grid
+        "061H072H",  # on the 0.1 degree grid
+        "073H084H",  # on the 0.1 degree grid
+        "085H096H",  # on the 0.1 degree grid
+        "097H102H",  # on the 0.1 degree grid
+    ] = "000H024H",
+    recursion: int = 0,
+) -> xr.Dataset:
+    """
+    Fetch the latest ARPEGE data for a given hour.
+    """
+    # let's give them time to upload data to the repo
+    runtime = (hour - pd.Timedelta("2h")).floor("6h")
+
+    url = f"{bare_url}{runtime.isoformat()}/"
+    url += f"{model.lower()}/{resolution}/{package}/"
+    filename = f"{model.lower()}__{resolution}__{package}__"
+    filename += f"{time_range}__{runtime.isoformat()}.grib2"
+    filename = filename.replace("+00:00", "Z")
+    url += filename
+    url = url.replace("+00:00", "Z")
+
+    if not (tempdir / filename).exists():
+        # If the file does not exist, we try to download it.
+        try:
+            await download_with_progress(client, url, tempdir / filename)
+        except Exception:
+            (tempdir / filename).unlink(missing_ok=True)  # remove the file if it exists
+            # If the download fails, we try to fetch the latest data
+            # (or survive with older data we may have in the /tmp directory)
+            if recursion >= 3:
+                raise  # do not insist too much in history
+            return await latest_data(
+                client,
+                hour - pd.Timedelta("6h"),
+                model,
+                resolution,
+                package,
+                time_range,
+                recursion + 1,
+            )
+
+    def _load_and_process_dataset() -> xr.Dataset:
+        log.info(f"Loading dataset from {tempdir / filename}")
+        ds = xr.open_dataset(
+            tempdir / filename,
+            engine="cfgrib",
+            backend_kwargs={
+                "filter_by_keys": {
+                    "typeOfLevel": "isobaricInhPa",
+                    "level": DEFAULT_LEVELS_37,
+                }
+            },
+        )
+        ds = ds.assign(step=ds.time + ds.step).drop_vars("time")
+        ds = ds.rename(step="time")
+        return ds  # type: ignore
+
+    return await asyncio.to_thread(_load_and_process_dataset)

tangram_weather/dist-frontend/__vite-optional-peer-dep_geotiff_weatherlayers-gl_false-Cjw5BclT.js

@@ -0,0 +1,6 @@
+const e = {};
+throw new Error('Could not resolve "geotiff" imported by "weatherlayers-gl".');
+export {
+  e as default
+};
+//# sourceMappingURL=__vite-optional-peer-dep_geotiff_weatherlayers-gl_false-Cjw5BclT.js.map

tangram_weather/dist-frontend/__vite-optional-peer-dep_geotiff_weatherlayers-gl_false-Cjw5BclT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__vite-optional-peer-dep_geotiff_weatherlayers-gl_false-Cjw5BclT.js","sources":["../__vite-optional-peer-dep:geotiff:weatherlayers-gl:false"],"sourcesContent":["export default {};throw new Error(`Could not resolve \"geotiff\" imported by \"weatherlayers-gl\".`)"],"names":["__viteOptionalPeerDep_geotiff_weatherlayersGl_false"],"mappings":"AAAA,MAAAA,IAAe,CAAA;AAAG,MAAM,IAAI,MAAM,6DAA6D;"}

tangram_weather/dist-frontend/index.css

@@ -0,0 +1 @@
+.wind-altitude-control[data-v-7a31b6fa]{position:absolute;bottom:20px;right:70px;background:#fffc;padding:10px;border-radius:5px;z-index:1000}.wind-altitude-control label[data-v-7a31b6fa]{font-family:B612,sans-serif;font-size:12px}input[type=range][data-v-7a31b6fa]{cursor:pointer;width:100%;margin-top:5px;background:#bab0ac;height:2px;border-radius:5px}