cloudnetpy 1.80.8__py3-none-any.whl → 1.81.0__py3-none-any.whl

cloudnetpy/categorize/freezing.py

@@ -3,6 +3,7 @@
 import logging
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy.interpolate import interp1d
 
@@ -11,7 +12,7 @@ from cloudnetpy.categorize.containers import ClassData
 from cloudnetpy.constants import T0
 
 
-def find_freezing_region(obs: ClassData, melting_layer: np.ndarray) -> np.ndarray:
+def find_freezing_region(obs: ClassData, melting_layer: npt.NDArray) -> npt.NDArray:
     """Finds freezing region using the model temperature and melting layer.
 
     Every profile that contains melting layer, subzero region starts from
@@ -60,16 +61,18 @@ def find_freezing_region(obs: ClassData, melting_layer: np.ndarray) -> np.ndarra
 
 
 def _is_all_freezing(
-    mean_melting_alt: np.ndarray,
-    t0_alt: np.ndarray,
-    height: np.ndarray,
+    mean_melting_alt: npt.NDArray,
+    t0_alt: npt.NDArray,
+    height: npt.NDArray,
 ) -> bool:
     no_detected_melting = mean_melting_alt.all() is ma.masked
     all_temperatures_below_freezing = (t0_alt <= height[0]).all()
     return no_detected_melting and all_temperatures_below_freezing
 
 
-def _find_mean_melting_alt(obs: ClassData, melting_layer: np.ndarray) -> ma.MaskedArray:
+def _find_mean_melting_alt(
+    obs: ClassData, melting_layer: npt.NDArray
+) -> ma.MaskedArray:
     if melting_layer.dtype != bool:
         msg = "melting_layer data type should be boolean"
         raise ValueError(msg)
@@ -78,7 +81,7 @@ def _find_mean_melting_alt(obs: ClassData, melting_layer: np.ndarray) -> ma.Mask
     return ma.median(melting_alts, axis=1)
 
 
-def find_t0_alt(temperature: np.ndarray, height: np.ndarray) -> np.ndarray:
+def find_t0_alt(temperature: npt.NDArray, height: npt.NDArray) -> npt.NDArray:
     """Interpolates altitudes where temperature goes below freezing.
 
     Args:
@@ -89,7 +92,7 @@ def find_t0_alt(temperature: np.ndarray, height: np.ndarray) -> np.ndarray:
         1-D array denoting altitudes where the temperature drops below 0 deg C.
 
     """
-    alt: np.ndarray = np.array([])
+    alt: npt.NDArray = np.array([])
     for prof in temperature:
         ind = np.where(prof < T0)[0][0]
         if ind == 0:

cloudnetpy/categorize/insects.py

@@ -1,6 +1,7 @@
 """Module to find insects from data."""
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy.ndimage import gaussian_filter
 
@@ -11,10 +12,10 @@ from cloudnetpy.categorize.containers import ClassData
 
 def find_insects(
     obs: ClassData,
-    melting_layer: np.ndarray,
-    liquid_layers: np.ndarray,
+    melting_layer: npt.NDArray,
+    liquid_layers: npt.NDArray,
     prob_lim: float = 0.8,
-) -> tuple[np.ndarray, np.ndarray]:
+) -> tuple[npt.NDArray, npt.NDArray]:
     """Returns insect probability and boolean array of insect presence.
 
     Insects are classified by estimating heuristic probability
@@ -52,7 +53,7 @@ def find_insects(
     return is_insects, ma.masked_where(insect_prob == 0, insect_prob)
 
 
-def _insect_probability(obs: ClassData) -> tuple[np.ndarray, np.ndarray]:
+def _insect_probability(obs: ClassData) -> tuple[npt.NDArray, npt.NDArray]:
     prob = _get_probabilities(obs)
     prob_from_ldr = _calc_prob_from_ldr(prob)
     prob_from_others = _calc_prob_from_all(prob)
@@ -87,7 +88,7 @@ def _get_smoothed_v(
     return ma.masked_where(obs.v.mask, smoothed_v)
 
 
-def _calc_prob_from_ldr(prob: dict) -> np.ndarray:
+def _calc_prob_from_ldr(prob: dict) -> npt.NDArray:
     """This is the most reliable proxy for insects."""
     if prob["ldr"] is not None:
         return prob["ldr"] * prob["temp_loose"]
@@ -100,7 +101,7 @@ def _calc_prob_from_ldr(prob: dict) -> np.ndarray:
     return np.zeros(prob["z_strong"].shape)
 
 
-def _calc_prob_from_all(prob: dict) -> np.ndarray:
+def _calc_prob_from_all(prob: dict) -> npt.NDArray:
     """This can be tried when LDR is not available. To detect insects without LDR
     unambiguously is difficult and might result in many false positives and/or false
     negatives.
@@ -111,8 +112,8 @@ def _calc_prob_from_all(prob: dict) -> np.ndarray:
 def _adjust_for_radar(
     obs: ClassData,
     prob: dict,
-    prob_from_others: np.ndarray,
-) -> np.ndarray:
+    prob_from_others: npt.NDArray,
+) -> npt.NDArray:
     """Adds radar-specific weighting to insect probabilities."""
     if "mira" in obs.radar_type.lower():
         prob_from_others *= prob["lwp"]
@@ -120,9 +121,9 @@ def _adjust_for_radar(
 
 
 def _fill_missing_pixels(
-    prob_from_ldr: np.ndarray,
-    prob_from_others: np.ndarray,
-) -> np.ndarray:
+    prob_from_ldr: npt.NDArray,
+    prob_from_others: npt.NDArray,
+) -> npt.NDArray:
     prob_combined = np.copy(prob_from_ldr)
     no_ldr = np.where(prob_from_ldr == 0)
     prob_combined[no_ldr] = prob_from_others[no_ldr]
@@ -130,12 +131,12 @@ def _fill_missing_pixels(
 
 
 def _screen_insects(
-    insect_prob,
-    insect_prob_no_ldr,
-    melting_layer,
-    liquid_layers,
-    obs,
-) -> np.ndarray:
+    insect_prob: npt.NDArray,
+    insect_prob_no_ldr: npt.NDArray,
+    melting_layer: npt.NDArray,
+    liquid_layers: npt.NDArray,
+    obs: ClassData,
+) -> npt.NDArray:
     def _screen_liquid_layers() -> None:
         prob[liquid_layers == 1] = 0
 

cloudnetpy/categorize/lidar.py

@@ -1,9 +1,11 @@
 """Lidar module, containing the :class:`Lidar` class."""
 
 import logging
+from os import PathLike
 from typing import Literal
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy.datasource import DataSource
@@ -18,13 +20,13 @@ class Lidar(DataSource):
 
     """
 
-    def __init__(self, full_path: str):
+    def __init__(self, full_path: str | PathLike) -> None:
         super().__init__(full_path)
         self.append_data(self.getvar("beta"), "beta")
         self._add_meta()
 
     def interpolate_to_grid(
-        self, time_new: np.ndarray, height_new: np.ndarray
+        self, time_new: npt.NDArray, height_new: npt.NDArray
     ) -> list[int]:
         """Interpolate beta using nearest neighbor."""
         max_height = 100  # m
@@ -70,7 +72,9 @@ class Lidar(DataSource):
         self.append_data(3.0, "beta_bias")
 
 
-def get_gap_ind(grid: np.ndarray, new_grid: np.ndarray, threshold: float) -> list[int]:
+def get_gap_ind(
+    grid: npt.NDArray, new_grid: npt.NDArray, threshold: float
+) -> list[int]:
     return [
         ind
         for ind, value in enumerate(new_grid)

cloudnetpy/categorize/melting.py

@@ -1,6 +1,7 @@
 """Functions to find melting layer from data."""
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy.ndimage import gaussian_filter
 
@@ -10,7 +11,7 @@ from cloudnetpy.categorize.containers import ClassData
 from cloudnetpy.constants import T0
 
 
-def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> np.ndarray:
+def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> npt.NDArray:
     """Finds melting layer from model temperature, ldr, and velocity.
 
     Melting layer is detected using linear depolarization ratio, *ldr*,
@@ -49,9 +50,9 @@ def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> np.ndarray:
     """
     melting_layer = np.zeros(obs.tw.shape, dtype=bool)
 
-    ldr_prof: np.ndarray | None = None
-    ldr_dprof: np.ndarray | None = None
-    ldr_diff: np.ndarray | None = None
+    ldr_prof: npt.NDArray | None = None
+    ldr_dprof: npt.NDArray | None = None
+    ldr_diff: npt.NDArray | None = None
     width_prof = None
 
     if hasattr(obs, "ldr"):
@@ -102,11 +103,11 @@ def find_melting_layer(obs: ClassData, *, smooth: bool = True) -> np.ndarray:
 
 
 def _find_melting_layer_from_ldr(
-    ldr_prof: np.ndarray,
-    ldr_dprof: np.ndarray,
-    v_prof: np.ndarray,
-    z_prof: np.ndarray,
-) -> np.ndarray | None:
+    ldr_prof: npt.NDArray,
+    ldr_dprof: npt.NDArray,
+    v_prof: npt.NDArray,
+    z_prof: npt.NDArray,
+) -> npt.NDArray | None:
     peak = int(np.argmax(ldr_prof))
     base, top = _basetop(ldr_dprof, peak)
     conditions = (
@@ -123,10 +124,10 @@ def _find_melting_layer_from_ldr(
 
 
 def _find_melting_layer_from_v(
-    v_prof: np.ndarray,
-    width_prof: np.ndarray | None,
-    height: np.ndarray,
-) -> np.ndarray | None:
+    v_prof: npt.NDArray,
+    width_prof: npt.NDArray | None,
+    height: npt.NDArray,
+) -> npt.NDArray | None:
     v = np.copy(v_prof[:-1])
     v_diff = np.diff(v_prof)
     v[v_diff < 0] = 0
@@ -156,14 +157,14 @@ def _find_melting_layer_from_v(
     return None
 
 
-def _basetop(dprof: np.ndarray, pind: int) -> tuple[int, int]:
+def _basetop(dprof: npt.NDArray, pind: int) -> tuple[int, int]:
     """Finds the base and top of ldr peak."""
     top = droplet.ind_top(dprof, pind, len(dprof), 10, 2)
     base = droplet.ind_base(dprof, pind, 10, 2)
     return base, top
 
 
-def _get_temp_indices(t_prof: np.ndarray, t_range: tuple) -> np.ndarray:
+def _get_temp_indices(t_prof: npt.NDArray, t_range: tuple) -> npt.NDArray:
     """Finds indices of temperature profile covering the given range."""
     ind = np.where((t_prof > min(t_range) + T0) & (t_prof < max(t_range) + T0))[0]
     return np.array([]) if len(ind) == 0 else np.arange(np.min(ind), np.max(ind) + 1)

cloudnetpy/categorize/model.py

@@ -1,6 +1,10 @@
 """Model module, containing the :class:`Model` class."""
 
+import os.path
+from os import PathLike
+
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy.interpolate import interp1d
 
@@ -49,13 +53,15 @@ class Model(DataSource):
         "specific_liquid_atten",
     )
 
-    def __init__(self, model_file: str, alt_site: float, options: dict | None = None):
+    def __init__(
+        self, model_file: str | PathLike, alt_site: float, options: dict | None = None
+    ) -> None:
         super().__init__(model_file)
         self.options = options
         self.source_type = _find_model_type(model_file)
         self.model_heights = self._get_model_heights(alt_site)
         self.mean_height = _calc_mean_height(self.model_heights)
-        self.height: np.ndarray
+        self.height: npt.NDArray
         self.data_sparse: dict = {}
         self.data_dense: dict = {}
         self._append_grid()
@@ -83,8 +89,8 @@ class Model(DataSource):
 
     def interpolate_to_grid(
         self,
-        time_grid: np.ndarray,
-        height_grid: np.ndarray,
+        time_grid: npt.NDArray,
+        height_grid: npt.NDArray,
     ) -> list:
         """Interpolates model variables to Cloudnet's dense time / height grid.
 
@@ -130,7 +136,7 @@ class Model(DataSource):
         self.append_data(np.array(self.time), "model_time")
         self.append_data(self.mean_height, "model_height")
 
-    def _get_model_heights(self, alt_site: float) -> np.ndarray:
+    def _get_model_heights(self, alt_site: float) -> npt.NDArray:
         """Returns model heights for each time step."""
         try:
             model_heights = self.dataset.variables["height"]
@@ -139,7 +145,7 @@ class Model(DataSource):
             raise ModelDataError(msg) from err
         return self.to_m(model_heights) + alt_site
 
-    def calc_attenuations(self, frequency: float):
+    def calc_attenuations(self, frequency: float) -> None:
         temperature = self.getvar("temperature")
         pressure = self.getvar("pressure")
         specific_humidity = self.getvar("q")
@@ -157,22 +163,23 @@ class Model(DataSource):
         )
 
 
-def _calc_mean_height(model_heights: np.ndarray) -> np.ndarray:
+def _calc_mean_height(model_heights: npt.NDArray) -> npt.NDArray:
     mean_height = ma.mean(model_heights, axis=0)
     return np.array(mean_height)
 
 
-def _find_model_type(file_name: str) -> str:
+def _find_model_type(file_name: str | PathLike) -> str:
     """Finds model type from the model filename."""
     possible_keys = ("gdas1", "icon", "ecmwf", "harmonie", "era5", "arpege")
+    basename = os.path.basename(file_name)
     for key in possible_keys:
-        if key in file_name:
+        if key in basename:
             return key
     msg = f"Unknown model type: {file_name}"
     raise ValueError(msg)
 
 
-def _find_number_of_valid_profiles(array: np.ndarray) -> int:
+def _find_number_of_valid_profiles(array: npt.NDArray) -> int:
     mask = ma.getmaskarray(array)
     all_masked_profiles = np.all(mask, axis=1)
     return np.count_nonzero(~all_masked_profiles)

cloudnetpy/categorize/mwr.py

@@ -1,7 +1,9 @@
 """Mwr module, containing the :class:`Mwr` class."""
 
-import numpy as np
+from os import PathLike
+
 import numpy.ma as ma
+import numpy.typing as npt
 
 from cloudnetpy import utils
 from cloudnetpy.constants import G_TO_KG
@@ -16,12 +18,12 @@ class Mwr(DataSource):
 
     """
 
-    def __init__(self, full_path: str):
+    def __init__(self, full_path: str | PathLike) -> None:
         super().__init__(full_path)
         self._init_lwp_data()
         self._init_lwp_error()
 
-    def rebin_to_grid(self, time_grid: np.ndarray) -> None:
+    def rebin_to_grid(self, time_grid: npt.NDArray) -> None:
         """Approximates lwp and its error in a grid using mean.
 
         Args:

cloudnetpy/categorize/radar.py

@@ -2,8 +2,10 @@
 
 import logging
 import math
+from os import PathLike
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy import constants
 
@@ -34,16 +36,16 @@ class Radar(DataSource):
 
     """
 
-    def __init__(self, full_path: str):
+    def __init__(self, full_path: str | PathLike) -> None:
         super().__init__(full_path, radar=True)
         self.radar_frequency = float(self.getvar("radar_frequency"))
         self.location = getattr(self.dataset, "location", "")
         self.source_type = getattr(self.dataset, "source", "")
-        self.height: np.ndarray
+        self.height: npt.NDArray
         self.altitude: float
         self._init_data()
 
-    def rebin_to_grid(self, time_new: np.ndarray) -> list:
+    def rebin_to_grid(self, time_new: npt.NDArray) -> list:
         """Rebins radar data in time.
 
         Args:
@@ -151,7 +153,7 @@ class Radar(DataSource):
 
     def _filter(
         self,
-        data: np.ndarray,
+        data: npt.NDArray,
         axis: int,
         min_coverage: float,
         z_limit: float,
@@ -224,7 +226,7 @@ class Radar(DataSource):
     def calc_errors(
         self,
         attenuations: RadarAttenuation,
-        is_clutter: np.ndarray,
+        is_clutter: npt.NDArray,
     ) -> None:
         """Calculates uncertainties of radar echo.
 
@@ -241,7 +243,7 @@ class Radar(DataSource):
 
         """
 
-        def _calc_sensitivity() -> np.ndarray:
+        def _calc_sensitivity() -> npt.NDArray:
             """Returns sensitivity of radar as function of altitude."""
             mean_gas_atten = ma.mean(attenuations.gas.amount, axis=0)
             z_sensitivity = z_power_min + log_range + mean_gas_atten
@@ -250,7 +252,7 @@ class Radar(DataSource):
             z_sensitivity[valid_values] = zc[valid_values]
             return z_sensitivity
 
-        def _calc_error() -> np.ndarray | float:
+        def _calc_error() -> npt.NDArray | float:
             """Returns error of radar as function of altitude.
 
             References:
@@ -317,7 +319,7 @@ class Radar(DataSource):
         for key in ("time", "height", "radar_frequency"):
             self.append_data(np.array(getattr(self, key)), key)
 
-    def add_location(self, time_new: np.ndarray):
+    def add_location(self, time_new: npt.NDArray) -> None:
         """Add latitude, longitude and altitude from nearest timestamp."""
         idx = np.searchsorted(self.time, time_new)
         idx_left = np.clip(idx - 1, 0, len(self.time) - 1)
@@ -343,9 +345,9 @@ class Radar(DataSource):
 
     def _rebin_velocity(
         self,
-        data: np.ndarray,
-        time_new: np.ndarray,
-    ) -> np.ndarray:
+        data: npt.NDArray,
+        time_new: npt.NDArray,
+    ) -> npt.NDArray:
         """Rebins Doppler velocity in polar coordinates."""
         folding_velocity = self._get_expanded_folding_velocity()
         # with the new shape (maximum value in every bin)
@@ -384,7 +386,7 @@ class Radar(DataSource):
         vel_scaled = ma.arctan2(vel_y_mean, vel_x_mean)
         return vel_scaled / (np.pi / max_folding_binned)
 
-    def _get_expanded_folding_velocity(self) -> np.ndarray:
+    def _get_expanded_folding_velocity(self) -> npt.NDArray:
         if "nyquist_velocity" in self.dataset.variables:
             fvel = self.getvar("nyquist_velocity")
         elif "prf" in self.dataset.variables:
@@ -425,7 +427,7 @@ class Radar(DataSource):
         return np.repeat(fvel.ravel(), chirp_size.ravel()).reshape((n_time, n_height))
 
 
-def _prf_to_folding_velocity(prf: np.ndarray, radar_frequency: float) -> np.ndarray:
+def _prf_to_folding_velocity(prf: npt.NDArray, radar_frequency: float) -> npt.NDArray:
     ghz_to_hz = 1e9
     if len(prf) != 1:
         msg = "Unable to determine folding velocity"

cloudnetpy/cli.py

@@ -2,19 +2,19 @@ import argparse
 import gzip
 import importlib
 import logging
-import os
 import re
 import shutil
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
+from os import PathLike
 from pathlib import Path
 from tempfile import TemporaryDirectory
-from typing import TYPE_CHECKING, Final
+from typing import TYPE_CHECKING, Final, cast
 
 import requests
 
 from cloudnetpy import concat_lib, instruments
-from cloudnetpy.categorize import generate_categorize
+from cloudnetpy.categorize import CategorizeInput, generate_categorize
 from cloudnetpy.exceptions import PlottingError
 from cloudnetpy.plotting import generate_figure
 from cloudnetpy.utils import md5sum
@@ -33,7 +33,7 @@ class Instrument:
     name: str
 
 
-def run(args: argparse.Namespace, tmpdir: str):
+def run(args: argparse.Namespace, tmpdir: str) -> None:
     cat_files = {}
 
     # Instrument based products
@@ -104,7 +104,7 @@ def _process_categorize(input_files: dict, args: argparse.Namespace) -> str | No
 
     try:
         logging.info("Processing categorize...")
-        generate_categorize(input_files, cat_filepath)
+        generate_categorize(cast("CategorizeInput", input_files), cat_filepath)
         logging.info("Processed categorize to %s", cat_filepath)
     except NameError:
         logging.info("No data available for this date.")
@@ -225,7 +225,7 @@ def _fetch_coefficient_files(calibration: dict, tmpdir: str) -> list:
     return coefficient_paths
 
 
-def _get_calibration(instrument: Instrument, args) -> dict:
+def _get_calibration(instrument: Instrument, args: argparse.Namespace) -> dict:
     params = {
         "date": args.date,
         "instrumentPid": instrument.pid,
@@ -484,7 +484,9 @@ def _check_input(files: list) -> None:
         raise ValueError(msg)
 
 
-def _plot(filepath: os.PathLike | str | None, product: str, args: argparse.Namespace):
+def _plot(
+    filepath: PathLike | str | None, product: str, args: argparse.Namespace
+) -> None:
     if filepath is None or (not args.plot and not args.show):
         return
     res = requests.get(f"{cloudnet_api_url}products/variables", timeout=60)
@@ -543,7 +545,7 @@ def _parse_products(product_argument: str) -> list[str]:
     return valid_products
 
 
-def main():
+def main() -> None:
     parser = argparse.ArgumentParser(
         description="Command line interface for running CloudnetPy."
     )

cloudnetpy/cloudnetarray.py

@@ -1,9 +1,10 @@
 """CloudnetArray class."""
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 
 import netCDF4
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import utils
@@ -26,13 +27,13 @@ class CloudnetArray:
 
     def __init__(
         self,
-        variable: netCDF4.Variable | np.ndarray | float,
+        variable: netCDF4.Variable | npt.NDArray | float,
         name: str,
         units_from_user: str | None = None,
         dimensions: Sequence[str] | None = None,
         data_type: str | None = None,
         source: str | None = None,
-    ):
+    ) -> None:
         self.variable = variable
         self.name = name
         self.data = self._init_data()
@@ -57,7 +58,7 @@ class CloudnetArray:
         """Masks data from given indices."""
         self.data[ind] = ma.masked
 
-    def rebin_data(self, time: np.ndarray, time_new: np.ndarray) -> np.ndarray:
+    def rebin_data(self, time: npt.NDArray, time_new: npt.NDArray) -> npt.NDArray:
         """Rebins `data` in time.
 
         Args:
@@ -108,14 +109,14 @@ class CloudnetArray:
         """Filters vertical artifacts from radar data."""
         self._filter(utils.filter_x_pixels)
 
-    def _filter(self, fun) -> None:
+    def _filter(self, fun: Callable[[npt.NDArray], npt.NDArray]) -> None:
         if not isinstance(self.data, ma.MaskedArray):
             self.data = ma.masked_array(self.data)
         is_data = (~self.data.mask).astype(int)
         is_data_filtered = fun(is_data)
         self.data[is_data_filtered == 0] = ma.masked
 
-    def _init_data(self) -> np.ndarray:
+    def _init_data(self) -> npt.NDArray:
         if isinstance(self.variable, netCDF4.Variable):
             return self.variable[:]
         if isinstance(self.variable, np.ndarray):
@@ -144,5 +145,5 @@ class CloudnetArray:
             return "i2"
         return "i4"
 
-    def __getitem__(self, ind: tuple) -> np.ndarray:
+    def __getitem__(self, ind: tuple) -> npt.NDArray:
         return self.data[ind]