doppy 0.5.9__cp310-abi3-macosx_10_12_x86_64.whl

doppy/raw/wls77.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from io import BufferedIOBase
+from pathlib import Path
+from typing import Any, Sequence
+
+import numpy as np
+import numpy.typing as npt
+from numpy import datetime64
+
+import doppy
+from doppy import exceptions
+from doppy.raw.utils import bytes_from_src
+from doppy.utils import merge_all_equal
+
+
+@dataclass
+class Wls77:
+    time: npt.NDArray[datetime64]  # dim: (time, )
+    altitude: npt.NDArray[np.float64]  # dim: (altitude, )
+    position: npt.NDArray[np.float64]  # dim: (time, )
+    temperature: npt.NDArray[np.float64]  # dim: (time, )
+    wiper_count: npt.NDArray[np.float64]  # dim: (time, )
+    cnr: npt.NDArray[np.float64]  # dim: (time, altitude)
+    radial_velocity: npt.NDArray[np.float64]  # dim: (time, altitude)
+    radial_velocity_deviation: npt.NDArray[np.float64]  # dim: (time, altitude)
+    wind_speed: npt.NDArray[np.float64]  # dim: (time, altitude)
+    wind_direction: npt.NDArray[np.float64]  # dim: (time, altitude)
+    zonal_wind: npt.NDArray[np.float64]  # u := zonal wind?, dim: (time, altitude)
+    meridional_wind: npt.NDArray[
+        np.float64
+    ]  # v := meridional wind?, dim: (time, altitude)
+    vertical_wind: npt.NDArray[np.float64]  # w := vertical wind?, dim: (time, altitude)
+    cnr_threshold: float
+    system_id: str
+
+    @classmethod
+    def from_srcs(
+        cls, data: Sequence[str | bytes | Path | BufferedIOBase]
+    ) -> list[Wls77]:
+        data_bytes = [bytes_from_src(src) for src in data]
+        raws = doppy.rs.raw.wls77.from_bytes_srcs(data_bytes)
+        try:
+            return [_raw_rs_to_wls77(r) for r in raws]
+        except RuntimeError as err:
+            raise exceptions.RawParsingError(err) from err
+
+    @classmethod
+    def from_src(cls, data: str | Path | bytes | BufferedIOBase) -> Wls77:
+        data_bytes = bytes_from_src(data)
+        try:
+            return _raw_rs_to_wls77(doppy.rs.raw.wls77.from_bytes_src(data_bytes))
+        except RuntimeError as err:
+            raise exceptions.RawParsingError(err) from err
+
+    def __getitem__(
+        self,
+        index: int
+        | slice
+        | list[int]
+        | npt.NDArray[np.int64]
+        | npt.NDArray[np.bool_]
+        | tuple[slice, slice],
+    ) -> Wls77:
+        if isinstance(index, (int, slice, list, np.ndarray)):
+            return Wls77(
+                time=self.time[index],
+                altitude=self.altitude,
+                position=self.position[index],
+                temperature=self.temperature[index],
+                wiper_count=self.wiper_count[index],
+                cnr=self.cnr[index],
+                radial_velocity=self.radial_velocity[index],
+                radial_velocity_deviation=self.radial_velocity_deviation[index],
+                wind_speed=self.wind_speed[index],
+                wind_direction=self.wind_direction[index],
+                zonal_wind=self.zonal_wind[index],
+                meridional_wind=self.meridional_wind[index],
+                vertical_wind=self.vertical_wind[index],
+                system_id=self.system_id,
+                cnr_threshold=self.cnr_threshold,
+            )
+        raise TypeError
+
+    def sorted_by_time(self) -> Wls77:
+        sort_indices = np.argsort(self.time)
+        return self[sort_indices]
+
+    @classmethod
+    def merge(cls, raws: Sequence[Wls77]) -> Wls77:
+        return cls(
+            time=np.concatenate(tuple(r.time for r in raws)),
+            altitude=raws[0].altitude,
+            position=np.concatenate(tuple(r.position for r in raws)),
+            temperature=np.concatenate(tuple(r.temperature for r in raws)),
+            wiper_count=np.concatenate(tuple(r.wiper_count for r in raws)),
+            cnr=np.concatenate(tuple(r.cnr for r in raws)),
+            radial_velocity=np.concatenate(tuple(r.radial_velocity for r in raws)),
+            radial_velocity_deviation=np.concatenate(
+                tuple(r.radial_velocity_deviation for r in raws)
+            ),
+            wind_speed=np.concatenate(tuple(r.wind_speed for r in raws)),
+            wind_direction=np.concatenate(tuple(r.wind_direction for r in raws)),
+            zonal_wind=np.concatenate(tuple(r.zonal_wind for r in raws)),
+            meridional_wind=np.concatenate(tuple(r.meridional_wind for r in raws)),
+            vertical_wind=np.concatenate(tuple(r.vertical_wind for r in raws)),
+            system_id=merge_all_equal("system_id", [r.system_id for r in raws]),
+            cnr_threshold=merge_all_equal(
+                "cnr_threshold", [r.cnr_threshold for r in raws]
+            ),
+        )
+
+    def non_strictly_increasing_timesteps_removed(self) -> Wls77:
+        if len(self.time) == 0:
+            return self
+        mask = np.ones_like(self.time, dtype=np.bool_)
+        latest_time = self.time[0]
+        for i, t in enumerate(self.time[1:], start=1):
+            if t <= latest_time:
+                mask[i] = False
+            else:
+                latest_time = t
+        return self[mask]
+
+
+def _raw_rs_to_wls77(
+    raw: dict[str, Any],
+) -> Wls77:
+    time_ts = raw["time"]
+    time = np.array(
+        [
+            datetime64(datetime.fromtimestamp(ts, timezone.utc).replace(tzinfo=None))
+            for ts in time_ts
+        ]
+    )
+
+    n = time.size
+
+    return Wls77(
+        time=time,
+        altitude=np.array(raw["altitude"], dtype=np.float64),
+        position=np.array(raw["position"], dtype=np.float64),
+        temperature=np.array(raw["temperature"], dtype=np.float64),
+        wiper_count=np.array(raw["wiper_count"], dtype=np.float64),
+        cnr=np.array(raw["cnr"], dtype=np.float64).reshape(n, -1),
+        radial_velocity=np.array(raw["radial_velocity"], dtype=np.float64).reshape(
+            n, -1
+        ),
+        radial_velocity_deviation=np.array(
+            raw["radial_velocity_deviation"], dtype=np.float64
+        ).reshape(n, -1),
+        wind_speed=np.array(raw["wind_speed"], dtype=np.float64).reshape(n, -1),
+        wind_direction=np.array(raw["wind_direction"], dtype=np.float64).reshape(n, -1),
+        zonal_wind=np.array(raw["zonal_wind"], dtype=np.float64).reshape(n, -1),
+        meridional_wind=np.array(raw["meridional_wind"], dtype=np.float64).reshape(
+            n, -1
+        ),
+        vertical_wind=np.array(raw["vertical_wind"], dtype=np.float64).reshape(n, -1),
+        cnr_threshold=raw["cnr_threshold"],
+        system_id=raw["system_id"],
+    )

doppy/utils.py

@@ -0,0 +1,24 @@
+from typing import TypeVar, cast
+
+import numpy as np
+from numpy.typing import NDArray
+
+T = TypeVar("T")
+NT = TypeVar("NT", bound=np.generic)
+
+
+def merge_all_equal(key: str, lst: list[T]) -> T:
+    if len(set(lst)) != 1:
+        raise ValueError(f"Cannot merge header key {key} values {lst}")
+    return lst[0]
+
+
+def merge_all_close(key: str, lst: list[NDArray[NT]]) -> NT:
+    if len(lst) == 0:
+        raise ValueError(f"Cannot merge empty list for key {key}")
+    if any(arr.size == 0 for arr in lst):
+        raise ValueError(f"Cannot merge key {key}, one or more arrays are empty.")
+    arr = np.concatenate([arr.flatten() for arr in lst])
+    if not np.allclose(arr, arr[0]):
+        raise ValueError(f"Cannot merge key {key}, values are not close enough")
+    return cast(NT, arr[0])

doppy-0.5.9.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: doppy
+Version: 0.5.9
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Requires-Dist: requests
+Requires-Dist: urllib3
+Requires-Dist: numpy
+Requires-Dist: netcdf4
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: mypy ; extra == 'dev'
+Requires-Dist: pyright ; extra == 'dev'
+Requires-Dist: ruff ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: types-requests ; extra == 'dev'
+Requires-Dist: py-spy ; extra == 'dev'
+Requires-Dist: maturin==1.8 ; extra == 'dev'
+Requires-Dist: release-version ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: xarray[io] ; extra == 'dev'
+Requires-Dist: seaborn ; extra == 'dev'
+Requires-Dist: tomli ; extra == 'dev'
+Requires-Dist: aiohttp ; extra == 'dev'
+Requires-Dist: tqdm ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+License-File: LICENSE
+Author-email: Niko Leskinen <niko.leskinen@fmi.fi>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/actris-cloudnet/doppy
+Project-URL: Repository, https://github.com/actris-cloudnet/doppy
+Project-URL: Changelog, https://github.com/actris-cloudnet/doppy/blob/main/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/actris-cloudnet/doppy/issues
+
+# Doppy – Doppler wind lidar processing
+
+[![CI](https://github.com/actris-cloudnet/doppy/actions/workflows/ci.yml/badge.svg)](https://github.com/actris-cloudnet/doppy/actions/workflows/ci.yml)
+[![PyPI version](https://badge.fury.io/py/doppy.svg)](https://badge.fury.io/py/doppy)
+
+## Products
+
+- Stare: [src](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/stare.py), [Cloudnet examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar&dateFrom=2024-06-05&dateTo=2024-06-05)
+- Wind: [src](https://github.com/actris-cloudnet/doppy/blob/main/src/doppy/product/wind.py), [Cloudnet examples](https://cloudnet.fmi.fi/search/visualizations?experimental=true&product=doppler-lidar-wind&dateFrom=2024-06-05&dateTo=2024-06-05)
+
+## Instruments
+
+- HALO Photonics Streamline lidars (stare, wind)
+- Leosphere WindCube WLS200S (wind)
+- Leosphere WindCube WLS70 (wind)
+
+## Install
+
+```sh
+pip install doppy
+```
+
+## Usage
+
+### Stare
+
+```python
+import doppy
+
+stare = doppy.product.Stare.from_halo_data(
+    data=LIST_OF_STARE_FILE_PATHS,
+    data_bg=LIST_OF_BACKGROUND_FILE_PATHS,
+    bg_correction_method=doppy.options.BgCorrectionMethod.FIT,
+)
+
+stare.write_to_netcdf(FILENAME)
+```
+
+### Stare with depolarisation
+
+```python
+import doppy
+
+stare_depol = doppy.product.StareDepol.from_halo_data(
+    co_data=LIST_OF_STARE_CO_FILE_PATHS,
+    co_data_bg=LIST_OF_BACKGROUND_CO_FILE_PATHS,
+    cross_data=LIST_OF_STARE_CROSS_FILE_PATHS,
+    cross_data_bg=LIST_OF_BACKGROUND_CROSS_FILE_PATHS,
+    bg_correction_method=doppy.options.BgCorrectionMethod.FIT,
+    polariser_bleed_through=0,
+)
+
+stare_depol.write_to_netcdf(FILENAME)
+```
+
+### Wind
+
+```python
+import doppy
+
+wind = doppy.product.Wind.from_halo_data(
+    data=LIST_OF_WIND_SCAN_HPL_FILES,
+)
+
+# You can also pass instrument azimuth offset in degrees as an option
+wind = doppy.product.Wind.from_halo_data(
+    data=LIST_OF_WIND_SCAN_HPL_FILES,
+    options=doppy.product.wind.Options(azimuth_offset_deg=30),
+)
+
+# For windcube wls200s use
+wind = doppy.product.Wind.from_windcube_data(
+    data=LIST_OF_VAD_NETCDF_FILES,
+)
+
+# For windcube wls70 use
+wind = doppy.product.Wind.from_wls70_data(
+    data=LIST_OF_RTD_FILES,
+)
+
+wind.write_to_netcdf(FILENAME)
+```
+
+### Raw files
+
+```python
+import doppy
+
+# Halo
+raws_hpl = doppy.raw.HaloHpl.from_srcs(LIST_OF_HPL_FILES)
+raws_bg = doppy.raw.HaloBg.from_srcs(LIST_OF_BACKGROUND_FILES)
+raw_system_params = doppy.raw.HaloSysParams.from_src(SYSTEM_PARAMS_FILENAME)
+
+# Windcube WLS200S
+raws_wls200s = doppy.raw.WindCube.from_vad_or_dbs_srcs(LIST_OF_VAD_NETCDF_FILES)
+
+# Windcube WLS70
+raws_wls70 = doppy.raw.Wls70.from_srcs(LIST_OF_RTD_FILES)
+```
+

doppy-0.5.9.dist-info/RECORD

@@ -0,0 +1,33 @@
+doppy-0.5.9.dist-info/METADATA,sha256=WVgfZybXdvNySG3RaZGdGyUQBeM6tBEaMkOGDaRQ7As,4404
+doppy-0.5.9.dist-info/WHEEL,sha256=XgR1VxSNigcUD69jquUcXL6D2aWFuJdAo2F9tNo_qRs,106
+doppy-0.5.9.dist-info/entry_points.txt,sha256=9b_Ca7vJoh6AwL3W8qAPh_UmJ_1Pa6hi-TDfCTDjvSk,43
+doppy-0.5.9.dist-info/licenses/LICENSE,sha256=V-0iroMNMI8ctnLgUau1kdFvwhkYhr9vi-5kWKxw2wc,1089
+doppy/__init__.py,sha256=Z9aEUlbPRWRUAoB8_-djkgrJuS4-6pjem4-mVSB6Z9I,191
+doppy/bench.py,sha256=xUsmwLCjNLXwO9l-_SCfq62jxXJ4eiwkS-WlCejcqZE,308
+doppy/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doppy/data/api.py,sha256=hUIqyCq1wFu89gamK7xK8R58eXAODWvLQHaaS5eu6OY,1875
+doppy/data/cache.py,sha256=cxCZ7HyEQt2EKAGEiMqx3wJ2-5Y3hEAEPQ_XB4gKlkk,1160
+doppy/data/exceptions.py,sha256=6CS6OHIWq8CqlxiceEvC1j0EfWUYoIfM7dW88apQVn4,89
+doppy/defaults.py,sha256=-jR_xAVLf_soZNDu3uJ6mhOZa9L1tfKtt0k0tI6Rd9s,472
+doppy/exceptions.py,sha256=OzdLXmKs3qZrvzwaI0pxjzpM2w9J5Of7dCo_Ekygecc,183
+doppy/netcdf.py,sha256=PuTCVK4yT4dkObo_w2D1lJroHg7l4DJFZxOi6jr1DkQ,4078
+doppy/options.py,sha256=73BDODO4OYHn2qOshhwz6u6G3J1kNd3uj6P0a3V4HBE,205
+doppy/product/__init__.py,sha256=C6s9cX20m9UwRsKo1lZH6TnYFfM5KmsX5MPUyShbgl4,235
+doppy/product/noise_utils.py,sha256=fP2bK2xfCUClQcDc_1FmLUUiU2d0KycrxkXLC5jmJAc,2629
+doppy/product/stare.py,sha256=e3mTaCw0H3Ud3Ql7pYQKzC368OUdQjaVQ8XOhAig1yo,26660
+doppy/product/stare_depol.py,sha256=gSlD13jGLRmHyTDADFs_MO6ECos6wwKF-TL7G7NwHAA,10718
+doppy/product/turbulence.py,sha256=hajTHFr6XXdul8oU9dw4Y58kBwRpUBIfiOfTcvSjq7M,8606
+doppy/product/utils.py,sha256=1mngeUrs_mlRO3Z-bq5OWoFEMxX5uuosLVge1Jrp76s,310
+doppy/product/wind.py,sha256=QyabapzOen_4oXLikmhjAjtlmOis18Ady57hQnrlzw8,15060
+doppy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doppy/raw/__init__.py,sha256=HE-7x27dfw-LJTvReZfspqzNx63Nl0v5ACdYs9EuOFQ,325
+doppy/raw/halo_bg.py,sha256=8t9j-SUF1yJht3vrT6KAYJQyxcg3W-0zr8h0jAEhWes,5815
+doppy/raw/halo_hpl.py,sha256=L83SmH7TLLR55ElG3NuvDt6iKA0rSQ3S8YLg6eQAHeE,16939
+doppy/raw/halo_sys_params.py,sha256=jclE4RbVg63iS3rVNYzvErKYAa3CI1q64xj3oai5tMc,5250
+doppy/raw/utils.py,sha256=EOWIaxAZIiRYa9dI1j50cSd4I058Zq7sz1HOeipZFTg,422
+doppy/raw/windcube.py,sha256=uL6htoeyrJ-zrHV_QM748TT0HyfA3rw7t2dQORx0OAU,19150
+doppy/raw/wls70.py,sha256=OfPczHZPKX4iqCcyjSv0nmkr1osy4pu6krNUi0-G0vM,6319
+doppy/raw/wls77.py,sha256=ciRNy0U1a4OuxbsHGt9HMHAa3Qqukaw57QeNQdkWUj8,6460
+doppy/rs.abi3.so,sha256=uNd4xU4JfBmQMYAkuRydwp5FwrQM1P0IrH-CIddYLgk,2709356
+doppy/utils.py,sha256=cY-tWrArrROX7lg_zJ2M4QJ6GUnU_BjhkUYL5aG9kbA,790
+doppy-0.5.9.dist-info/RECORD,,

doppy-0.5.9.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.10.2)
+Root-Is-Purelib: false
+Tag: cp310-abi3-macosx_10_12_x86_64

doppy-0.5.9.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+doppy=doppy.__main__:app

doppy-0.5.9.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Finnish Meteorological Institute
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.