doppy 0.0.1__cp310-abi3-macosx_10_12_x86_64.whl

doppy/__init__.py

@@ -0,0 +1,6 @@
+from doppy import data, netcdf, options, product, raw
+from doppy.rs import __version__
+
+from . import bench
+
+__all__ = ["raw", "options", "product", "netcdf", "bench", "data", "__version__"]

doppy/__main__.py

@@ -0,0 +1,25 @@
+import typer
+
+app = typer.Typer()
+
+
+@app.command()
+def parse(file: str, merge: bool = False) -> None:
+    """
+    Parse raw hpl files into netCDF files
+    """
+    print(f"Hello {file}")
+
+
+@app.command()
+def stare() -> None:
+    print("stare cmd")
+
+
+@app.command()
+def wind() -> None:
+    print("wind cmd")
+
+
+if __name__ == "__main__":
+    app()

doppy/bench.py

@@ -0,0 +1,12 @@
+import time
+
+
+class Timer:
+    def __init__(self):
+        self.start = None
+
+    def __enter__(self):
+        self.start = time.time()
+
+    def __exit__(self, type, value, traceback):
+        print(f"Elapsed time: {time.time() - self.start:.2f}")

doppy/data/api.py

@@ -0,0 +1,44 @@
+import io
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from doppy.data import exceptions
+from doppy.data.cache import cached_record
+
+
+class Api:
+    def __init__(self, cache: bool = False) -> None:
+        retries = Retry(total=10, backoff_factor=0.2)
+        adapter = HTTPAdapter(max_retries=retries)
+        session = requests.Session()
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        self.session = session
+        self.api_endpoint = "https://cloudnet.fmi.fi/api"
+        self.cache = cache
+
+    def get(self, path: str, params: dict[str, str]) -> list:
+        res = self.session.get(
+            f"{self.api_endpoint}/{path}", params=params, timeout=1800
+        )
+        if res.ok:
+            data = res.json()
+            if isinstance(data, list):
+                return data
+            raise exceptions.ApiRequestError(
+                f"Unexpected response type from api: {type(data)}"
+            )
+        raise exceptions.ApiRequestError(f"Api request error: {res.status_code}")
+
+    def get_raw_records(self, site: str, date: str) -> list:
+        return self.get(
+            "raw-files",
+            params={"instrument": "halo-doppler-lidar", "site": site, "date": date},
+        )
+
+    def get_record_content(self, rec: dict) -> io.BytesIO:
+        if self.cache:
+            return cached_record(rec, self.session)
+        return io.BytesIO(self.session.get(rec["downloadUrl"]).content)

doppy/data/cache.py

@@ -0,0 +1,34 @@
+import shutil
+from io import BytesIO
+from pathlib import Path
+
+from requests import Session
+
+
+def cached_record(
+    record: dict, session: Session, check_disk_usage: bool = True
+) -> BytesIO:
+    cache_dir = Path("cache")
+    path = cache_dir / record["uuid"]
+
+    if check_disk_usage:
+        HUNDRED_GIGABYTES_AS_BYTES = 100 * 1024 * 1024 * 1024
+
+        _, _, disk_free = shutil.disk_usage("./")
+        if disk_free < HUNDRED_GIGABYTES_AS_BYTES:
+            _clear_dir(cache_dir)
+
+    if path.is_file():
+        return BytesIO(path.read_bytes())
+    else:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        content = session.get(record["downloadUrl"]).content
+        with path.open("wb") as f:
+            f.write(content)
+        return BytesIO(content)
+
+
+def _clear_dir(path: Path) -> None:
+    for f in path.glob("**/*"):
+        if f.is_file():
+            f.unlink()

doppy/data/exceptions.py

@@ -0,0 +1,6 @@
+class ApiRequestError(Exception):
+    pass
+
+
+class CliArgumentError(Exception):
+    pass

doppy/defaults.py

@@ -0,0 +1,3 @@
+class Halo:
+    wavelength = 1.565e-6
+

doppy/exceptions.py

@@ -0,0 +1,10 @@
+class DoppyException(Exception):
+    pass
+
+
+class RawParsingError(DoppyException):
+    pass
+
+
+class NoDataError(DoppyException):
+    pass

doppy/netcdf.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal, TypeAlias
+
+import netCDF4
+import numpy as np
+import numpy.typing as npt
+
+NetCDFDataType: TypeAlias = Literal["f4", "f8", "i4", "i8", "u4", "u8"]
+
+
+class Dataset:
+    def __init__(self) -> None:
+        self.nc = netCDF4.Dataset("inmemory.nc", mode="w", memory=1028)
+
+    def add_dimension(self, dim: str) -> Dataset:
+        self.nc.createDimension(dim, None)
+        return self
+
+    def add_time(
+        self,
+        name: str,
+        dimensions: tuple[str, ...],
+        data: npt.NDArray[np.datetime64],
+        dtype: NetCDFDataType,
+        standard_name: str | None = None,
+        long_name: str | None = None,
+    ) -> Dataset:
+        time, units, calendar = _convert_time(data)
+        var = self.nc.createVariable(name, dtype, dimensions)
+        var.units = units
+        var.calendar = calendar
+        var[:] = time
+        if standard_name is not None:
+            var.standard_name = standard_name
+        if long_name is not None:
+            var.long_name = long_name
+        return self
+
+    def add_variable(
+        self,
+        name: str,
+        dimensions: tuple[str, ...],
+        units: str,
+        data: npt.NDArray[np.float64],
+        dtype: NetCDFDataType,
+        standard_name: str | None = None,
+        long_name: str | None = None,
+        mask: npt.NDArray[np.bool_] | None = None,
+    ) -> Dataset:
+        var = self.nc.createVariable(name, dtype, dimensions)
+        var.units = units
+        if mask is not None:
+            var[:] = np.ma.masked_array(data, mask)  # type: ignore
+        else:
+            var[:] = data
+        if standard_name is not None:
+            var.standard_name = standard_name
+        if long_name is not None:
+            var.long_name = long_name
+        return self
+
+    def add_scalar_variable(
+        self,
+        name: str,
+        units: str,
+        data: np.float64 | np.int64 | float | int,
+        dtype: NetCDFDataType,
+        standard_name: str | None = None,
+        long_name: str | None = None,
+        mask: npt.NDArray[np.bool_] | None = None,
+    ) -> Dataset:
+        var = self.nc.createVariable(name, dtype)
+        var.units = units
+        var[:] = data
+        if standard_name is not None:
+            var.standard_name = standard_name
+        if long_name is not None:
+            var.long_name = long_name
+        return self
+
+    def close(self) -> memoryview:
+        buf = self.nc.close()
+        if isinstance(buf, memoryview):
+            return buf
+        raise TypeError
+
+    def write(self, path: str | Path) -> None:
+        buf = self.nc.close()
+        with Path(path).open("wb") as f:
+            f.write(buf)
+
+
+def _convert_time(
+    time: npt.NDArray[np.datetime64],
+) -> tuple[npt.NDArray[np.float64], str, str]:
+    """
+    Parameters
+    ----------
+    time : npt.NDArray[np.datetime64["us"]]
+        Must be represented in UTC
+    """
+    if time.dtype != "<M8[us]":
+        raise TypeError("time must be datetime64[us]")
+    MICROSECONDS_TO_HOURS = 1 / (1e6 * 3600)
+    start_of_day = time.min().astype("datetime64[D]")
+    hours_since_start_of_day = (time - start_of_day).astype(
+        np.float64
+    ) * MICROSECONDS_TO_HOURS
+    units = f"hours since {np.datetime_as_string(start_of_day)} 00:00:00 +0000"
+    calendar = "standard"
+    return hours_since_start_of_day, units, calendar

doppy/options.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class BgCorrectionMethod(Enum):
+    FIT = "fit"
+    MEAN = "mean"
+    PRE_COMPUTED = "pre_computed"
+
+
+class BgFitMethod(Enum):
+    LIN = "lin"
+    EXP = "exp"
+    EXPLIN = "explin"

doppy/product/__init__.py

@@ -0,0 +1,3 @@
+from doppy.product.stare import Stare
+
+__all__ = ["Stare"]