cloudnetpy 1.80.8__tar.gz → 1.81.0__tar.gz

{cloudnetpy-1.80.8/cloudnetpy.egg-info → cloudnetpy-1.81.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.80.8
+Version: 1.81.0
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License
@@ -47,6 +47,7 @@ Requires-Dist: requests
 Requires-Dist: rpgpy>=0.14.5
 Requires-Dist: scikit-image
 Requires-Dist: scipy
+Requires-Dist: typing-extensions
 Provides-Extra: test
 Requires-Dist: cloudnetpy_qc; extra == "test"
 Requires-Dist: mypy; extra == "test"

cloudnetpy-1.81.0/cloudnetpy/categorize/__init__.py

@@ -0,0 +1 @@
+from .categorize import CategorizeInput, generate_categorize

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/atmos_utils.py

@@ -9,7 +9,7 @@ import cloudnetpy.constants as con
 from cloudnetpy import utils
 
 
-def calc_wet_bulb_temperature(model_data: dict) -> np.ndarray:
+def calc_wet_bulb_temperature(model_data: dict) -> npt.NDArray:
     """Calculate wet-bulb temperature iteratively.
 
     Args:
@@ -30,7 +30,7 @@ def calc_wet_bulb_temperature(model_data: dict) -> np.ndarray:
     W = calc_mixing_ratio(vp, pressure)
     L_v_0 = 2501e3  # Latent heat of vaporization at 0degC (J kg-1)
 
-    def f(tw):
+    def f(tw: npt.NDArray) -> npt.NDArray:
         svp = calc_saturation_vapor_pressure(c2k(tw))
         W_s = calc_mixing_ratio(svp, pressure)
         C_p_w = 0.0265 * tw**2 - 1.7688 * tw + 4205.6  # Eq. 6 (J kg-1 C-1)
@@ -86,17 +86,17 @@ def calc_vapor_pressure(
     )
 
 
-def c2k(temp: np.ndarray) -> np.ndarray:
+def c2k(temp: npt.NDArray) -> npt.NDArray:
     """Converts Celsius to Kelvins."""
     return ma.array(temp) + 273.15
 
 
-def k2c(temp: np.ndarray) -> np.ndarray:
+def k2c(temp: npt.NDArray) -> npt.NDArray:
     """Converts Kelvins to Celsius."""
     return ma.array(temp) - 273.15
 
 
-def find_cloud_bases(array: np.ndarray) -> np.ndarray:
+def find_cloud_bases(array: npt.NDArray) -> npt.NDArray:
     """Finds bases of clouds.
 
     Args:
@@ -111,7 +111,7 @@ def find_cloud_bases(array: np.ndarray) -> np.ndarray:
     return np.diff(array_padded, axis=1) == 1
 
 
-def find_cloud_tops(array: np.ndarray) -> np.ndarray:
+def find_cloud_tops(array: npt.NDArray) -> npt.NDArray:
     """Finds tops of clouds.
 
     Args:
@@ -127,8 +127,8 @@ def find_cloud_tops(array: np.ndarray) -> np.ndarray:
 
 
 def find_lowest_cloud_bases(
-    cloud_mask: np.ndarray,
-    height: np.ndarray,
+    cloud_mask: npt.NDArray,
+    height: npt.NDArray,
 ) -> ma.MaskedArray:
     """Finds altitudes of cloud bases."""
     cloud_heights = cloud_mask * height
@@ -136,8 +136,8 @@ def find_lowest_cloud_bases(
 
 
 def find_highest_cloud_tops(
-    cloud_mask: np.ndarray,
-    height: np.ndarray,
+    cloud_mask: npt.NDArray,
+    height: npt.NDArray,
 ) -> ma.MaskedArray:
     """Finds altitudes of cloud tops."""
     cloud_heights = cloud_mask * height
@@ -145,15 +145,15 @@ def find_highest_cloud_tops(
     return _find_lowest_heights(cloud_heights_flipped)
 
 
-def _find_lowest_heights(cloud_heights: np.ndarray) -> ma.MaskedArray:
+def _find_lowest_heights(cloud_heights: npt.NDArray) -> ma.MaskedArray:
     inds = (cloud_heights != 0).argmax(axis=1)
     heights = np.array([cloud_heights[i, ind] for i, ind in enumerate(inds)])
     return ma.masked_equal(heights, 0.0)
 
 
 def fill_clouds_with_lwc_dz(
-    temperature: np.ndarray, pressure: np.ndarray, is_liquid: np.ndarray
-) -> np.ndarray:
+    temperature: npt.NDArray, pressure: npt.NDArray, is_liquid: npt.NDArray
+) -> npt.NDArray:
     """Fills liquid clouds with lwc change rate at the cloud bases.
 
     Args:
@@ -173,10 +173,10 @@ def fill_clouds_with_lwc_dz(
 
 
 def get_lwc_change_rate_at_bases(
-    temperature: np.ndarray,
-    pressure: np.ndarray,
-    is_liquid: np.ndarray,
-) -> np.ndarray:
+    temperature: npt.NDArray,
+    pressure: npt.NDArray,
+    is_liquid: npt.NDArray,
+) -> npt.NDArray:
     """Finds LWC change rate in liquid cloud bases.
 
     Args:
@@ -198,7 +198,9 @@ def get_lwc_change_rate_at_bases(
     return lwc_dz
 
 
-def calc_lwc_change_rate(temperature: np.ndarray, pressure: np.ndarray) -> np.ndarray:
+def calc_lwc_change_rate(
+    temperature: npt.NDArray, pressure: npt.NDArray
+) -> npt.NDArray:
     """Returns rate of change of condensable water (LWC).
 
     Calculates the theoretical adiabatic rate of increase of LWC
@@ -242,7 +244,7 @@ def calc_lwc_change_rate(temperature: np.ndarray, pressure: np.ndarray) -> np.nd
     return dqs_dz * air_density
 
 
-def calc_saturation_vapor_pressure(temperature: np.ndarray) -> np.ndarray:
+def calc_saturation_vapor_pressure(temperature: npt.NDArray) -> npt.NDArray:
     """Goff-Gratch formula for saturation vapor pressure over water adopted by WMO.
 
     Args:
@@ -266,7 +268,9 @@ def calc_saturation_vapor_pressure(temperature: np.ndarray) -> np.ndarray:
     ) * con.HPA_TO_PA
 
 
-def calc_mixing_ratio(vapor_pressure: np.ndarray, pressure: np.ndarray) -> np.ndarray:
+def calc_mixing_ratio(
+    vapor_pressure: npt.NDArray, pressure: npt.NDArray
+) -> npt.NDArray:
     """Calculates mixing ratio from partial vapor pressure and pressure.
 
     Args:
@@ -281,10 +285,10 @@ def calc_mixing_ratio(vapor_pressure: np.ndarray, pressure: np.ndarray) -> np.nd
 
 
 def calc_air_density(
-    pressure: np.ndarray,
-    temperature: np.ndarray,
-    svp_mixing_ratio: np.ndarray,
-) -> np.ndarray:
+    pressure: npt.NDArray,
+    temperature: npt.NDArray,
+    svp_mixing_ratio: npt.NDArray,
+) -> npt.NDArray:
     """Calculates air density (kg m-3).
 
     Args:
@@ -299,7 +303,7 @@ def calc_air_density(
     return pressure / (con.RS * temperature * (0.6 * svp_mixing_ratio + 1))
 
 
-def calc_adiabatic_lwc(lwc_dz: np.ndarray, height: np.ndarray) -> np.ndarray:
+def calc_adiabatic_lwc(lwc_dz: npt.NDArray, height: npt.NDArray) -> npt.NDArray:
     """Calculates adiabatic liquid water content (kg m-3).
 
     Args:
@@ -319,8 +323,8 @@ def calc_adiabatic_lwc(lwc_dz: np.ndarray, height: np.ndarray) -> np.ndarray:
 
 
 def normalize_lwc_by_lwp(
-    lwc_adiabatic: np.ndarray, lwp: np.ndarray, height: np.ndarray
-) -> np.ndarray:
+    lwc_adiabatic: npt.NDArray, lwp: npt.NDArray, height: npt.NDArray
+) -> npt.NDArray:
     """Finds LWC that would produce measured LWP.
 
     Calculates LWP-weighted, normalized LWC. This is the measured

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/attenuations/__init__.py

@@ -2,8 +2,8 @@ from dataclasses import dataclass
 from typing import Annotated
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
-from numpy.typing import NDArray
 
 from cloudnetpy import constants as con
 from cloudnetpy.utils import path_lengths_from_ground
@@ -13,8 +13,8 @@ from cloudnetpy.utils import path_lengths_from_ground
 class Attenuation:
     amount: Annotated[ma.MaskedArray, "float32"]
     error: Annotated[ma.MaskedArray, "float32"]
-    attenuated: NDArray[np.bool_]
-    uncorrected: NDArray[np.bool_]
+    attenuated: npt.NDArray[np.bool_]
+    uncorrected: npt.NDArray[np.bool_]
 
 
 @dataclass
@@ -26,7 +26,7 @@ class RadarAttenuation:
 
 
 def calc_two_way_attenuation(
-    height: np.ndarray, specific_attenuation: ma.MaskedArray
+    height: npt.NDArray, specific_attenuation: ma.MaskedArray
 ) -> ma.MaskedArray:
     """Calculates two-way attenuation (dB) for given specific attenuation
     (dB km-1) and height (m).

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/attenuations/liquid_attenuation.py

@@ -1,4 +1,4 @@
-import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 import cloudnetpy.constants as con
@@ -16,7 +16,9 @@ class LiquidAttenuation:
         algorithms: the Cloudnet Instrument Synergy/Target Categorization product.
     """
 
-    def __init__(self, data: Observations, classification: ClassificationResult):
+    def __init__(
+        self, data: Observations, classification: ClassificationResult
+    ) -> None:
         self._model = data.model.data_dense
         self._liquid_in_pixel = classification.category_bits.droplet
         self._height = data.radar.height
@@ -50,7 +52,7 @@ class LiquidAttenuation:
         )
 
     def _calc_liquid_atten(
-        self, lwp: ma.MaskedArray, lwc_dz: np.ndarray
+        self, lwp: ma.MaskedArray, lwc_dz: npt.NDArray
     ) -> ma.MaskedArray:
         """Finds radar liquid attenuation."""
         lwp = lwp.copy()
@@ -60,7 +62,7 @@ class LiquidAttenuation:
         return self._calc_two_way_attenuation(lwc_scaled)
 
     def _calc_liquid_atten_err(
-        self, lwp_error: ma.MaskedArray, lwc_dz: np.ndarray
+        self, lwp_error: ma.MaskedArray, lwc_dz: npt.NDArray
     ) -> ma.MaskedArray:
         """Finds radar liquid attenuation error."""
         lwc_err_scaled = atmos_utils.normalize_lwc_by_lwp(
@@ -68,7 +70,7 @@ class LiquidAttenuation:
         )
         return self._calc_two_way_attenuation(lwc_err_scaled)
 
-    def _calc_two_way_attenuation(self, lwc_scaled: np.ndarray) -> ma.MaskedArray:
+    def _calc_two_way_attenuation(self, lwc_scaled: npt.NDArray) -> ma.MaskedArray:
         """Calculates liquid attenuation (dB).
 
         Args:

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/attenuations/melting_attenuation.py

@@ -1,4 +1,4 @@
-import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 import cloudnetpy.constants as con
@@ -55,8 +55,8 @@ def calc_melting_attenuation(
 
 
 def _calc_melting_attenuation(
-    rainfall_rate: np.ndarray, frequency: float
-) -> np.ndarray:
+    rainfall_rate: npt.NDArray, frequency: float
+) -> npt.NDArray:
     """Calculates total attenuation due to melting layer (dB).
 
     References:

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/attenuations/rain_attenuation.py

@@ -1,6 +1,6 @@
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
-from numpy.typing import NDArray
 
 import cloudnetpy.constants as con
 from cloudnetpy import utils
@@ -53,7 +53,7 @@ def calc_rain_attenuation(
 
 def _find_regions(
     classification: ClassificationResult,
-) -> tuple[NDArray[np.bool_], NDArray[np.bool_]]:
+) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.bool_]]:
     """Finds regions where rain attenuation is present and can be corrected or not."""
     warm_region = ~classification.category_bits.freezing
     is_rain = utils.transpose(classification.is_rain).astype(bool)
@@ -63,8 +63,8 @@ def _find_regions(
 
 
 def _calc_rain_specific_attenuation(
-    rainfall_rate: np.ndarray, frequency: float
-) -> np.ndarray:
+    rainfall_rate: npt.NDArray, frequency: float
+) -> npt.NDArray:
     """Calculates specific attenuation due to rain (dB km-1).
 
     References:

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/categorize.py

@@ -2,10 +2,15 @@
 
 import dataclasses
 import logging
+from collections.abc import Sequence
 from dataclasses import fields
+from os import PathLike
+from typing import TypedDict
+from uuid import UUID
 
 import numpy as np
 from numpy.typing import NDArray
+from typing_extensions import NotRequired
 
 from cloudnetpy import output, utils
 from cloudnetpy.categorize import attenuation, classify
@@ -22,12 +27,21 @@ from cloudnetpy.metadata import COMMON_ATTRIBUTES, MetaData
 from cloudnetpy.products.product_tools import CategoryBits, QualityBits
 
 
+class CategorizeInput(TypedDict):
+    radar: str | PathLike
+    lidar: str | PathLike
+    model: str | PathLike
+    disdrometer: NotRequired[str | PathLike]
+    mwr: NotRequired[str | PathLike]
+    lv0_files: NotRequired[Sequence[str | PathLike]]
+
+
 def generate_categorize(
-    input_files: dict,
-    output_file: str,
-    uuid: str | None = None,
+    input_files: CategorizeInput,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
     options: dict | None = None,
-) -> str:
+) -> UUID:
     """Generates a Cloudnet Level 1c categorize file.
 
     This function rebins measurements into a common height/time grid
@@ -73,6 +87,7 @@ def generate_categorize(
         >>> input_files['lv0_files'] = ['file1.LV0', 'file2.LV0']  # Add RPG LV0 files
         >>> generate_categorize(input_files, 'output.nc')  # Use the Voodoo method
     """
+    uuid = utils.get_uuid(uuid)
 
     def _interpolate_to_cloudnet_grid() -> list[int]:
         if data.disdrometer is not None:
@@ -199,17 +214,18 @@ def generate_categorize(
         attributes = output.add_time_attribute(attributes, date, "model_time")
         attributes = output.add_source_attribute(attributes, data)
         output.update_attributes(cloudnet_arrays, attributes)
-        return _save_cat(output_file, data, cloudnet_arrays, uuid)
+        _save_cat(output_file, data, cloudnet_arrays, uuid)
+        return uuid
     finally:
         _close_all()
 
 
 def _save_cat(
-    full_path: str,
+    full_path: str | PathLike,
     data_obs: Observations,
     cloudnet_arrays: dict,
-    uuid: str | None,
-) -> str:
+    uuid: UUID,
+) -> None:
     """Creates a categorize netCDF4 file and saves all data into it."""
     dims = {
         "time": len(data_obs.radar.time),
@@ -223,7 +239,6 @@ def _save_cat(
         file_type += "-voodoo"
 
     with output.init_file(full_path, dims, cloudnet_arrays, uuid) as nc:
-        uuid_out = nc.file_uuid
         nc.cloudnet_file_type = file_type
         output.copy_global(
             data_obs.radar.dataset,
@@ -246,7 +261,6 @@ def _save_cat(
             nc.voodoonet_version = voodoonet.version.__version__
         output.add_source_instruments(nc, data_obs)
         output.merge_history(nc, file_type, data_obs)
-    return uuid_out
 
 
 def _classes_to_bits(data: QualityBits | CategoryBits) -> NDArray[np.int_]:
@@ -411,7 +425,7 @@ CATEGORIZE_ATTRIBUTES = {
         long_name="Minimum detectable radar reflectivity",
         units="dBZ",
         comment=COMMENTS["Z_sensitivity"],
-        dimensions=("time", "height"),
+        dimensions=("height",),
     ),
     "v": COMMON_ATTRIBUTES["v"]._replace(dimensions=("time", "height")),
     "width": COMMON_ATTRIBUTES["width"]._replace(dimensions=("time", "height")),

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/classify.py

@@ -1,7 +1,7 @@
 import numpy as np
+import numpy.typing as npt
 import skimage
 from numpy import ma
-from numpy.typing import NDArray
 
 from cloudnetpy import utils
 from cloudnetpy.categorize import (
@@ -67,9 +67,10 @@ def classify_measurements(data: Observations) -> ClassificationResult:
         import voodoonet  # noqa: PLC0415
 
         options = voodoonet.VoodooOptions(progress_bar=False)
-        target_time = voodoonet.utils.decimal_hour2unix(obs.date, obs.time)
+        dumb_date = obs.date.isoformat().split("-")
+        target_time = voodoonet.utils.decimal_hour2unix(dumb_date, obs.time)
         liquid_prob = voodoonet.infer(
-            obs.lv0_files, target_time=target_time, options=options
+            list(obs.lv0_files), target_time=target_time, options=options
         )
         liquid_from_radar = liquid_prob > 0.55
         liquid_from_radar = _remove_false_radar_liquid(
@@ -131,9 +132,9 @@ def _fix_super_cold_liquid(obs: ClassData, bits: CategoryBits) -> None:
 
 
 def _remove_false_radar_liquid(
-    liquid_from_radar: np.ndarray,
-    liquid_from_lidar: np.ndarray,
-) -> NDArray[np.bool_]:
+    liquid_from_radar: npt.NDArray,
+    liquid_from_lidar: npt.NDArray,
+) -> npt.NDArray[np.bool_]:
     """Removes radar-liquid below lidar-detected liquid bases."""
     lidar_liquid_bases = atmos_utils.find_cloud_bases(liquid_from_lidar)
     for prof, base in zip(*np.where(lidar_liquid_bases), strict=True):
@@ -144,7 +145,7 @@ def _remove_false_radar_liquid(
 def _find_aerosols(
     obs: ClassData,
     bits: CategoryBits,
-) -> NDArray[np.bool_]:
+) -> npt.NDArray[np.bool_]:
     """Estimates aerosols from lidar backscattering.
 
     Aerosols are lidar signals that are: a) not falling, b) not liquid droplets.
@@ -167,7 +168,7 @@ def _fix_undetected_melting_layer(bits: CategoryBits) -> None:
     bits.melting[:, 1:][transition] = True
 
 
-def _find_drizzle_and_falling(bits: CategoryBits) -> np.ndarray:
+def _find_drizzle_and_falling(bits: CategoryBits) -> npt.NDArray:
     """Classifies pixels as falling, drizzle and others.
 
     Args:

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/containers.py

@@ -1,6 +1,9 @@
+from collections.abc import Sequence
 from dataclasses import dataclass
+from os import PathLike
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import utils
@@ -21,16 +24,16 @@ class Observations:
     model: Model
     mwr: Mwr | None = None
     disdrometer: Disdrometer | None = None
-    lv0_files: list[str] | None = None
+    lv0_files: Sequence[str | PathLike] | None = None
 
 
 @dataclass
 class ClassificationResult:
     category_bits: CategoryBits
-    is_rain: np.ndarray
-    is_clutter: np.ndarray
-    insect_prob: np.ndarray
-    liquid_prob: np.ndarray | None
+    is_rain: npt.NDArray
+    is_clutter: npt.NDArray
+    insect_prob: npt.NDArray
+    liquid_prob: npt.NDArray | None
 
 
 class ClassData:
@@ -59,7 +62,7 @@ class ClassData:
 
     """
 
-    def __init__(self, data: Observations):
+    def __init__(self, data: Observations) -> None:
         self.data = data
         self.z = data.radar.data["Z"][:]
         self.v = data.radar.data["v"][:]
@@ -84,7 +87,7 @@ class ClassData:
         self.lv0_files = data.lv0_files
         self.date = data.radar.get_date()
 
-    def _find_profiles_with_rain(self) -> np.ndarray:
+    def _find_profiles_with_rain(self) -> npt.NDArray:
         is_rain = self._find_rain_from_radar_echo()
         rain_from_disdrometer = self._find_rain_from_disdrometer()
         ind = ~rain_from_disdrometer.mask
@@ -94,7 +97,7 @@ class ClassData:
         is_positive_temp = self.tw[:, first_valid_ind] > T0 + 5  # Filter snowfall
         return is_rain & is_positive_temp
 
-    def _find_rain_from_radar_echo(self) -> np.ndarray:
+    def _find_rain_from_radar_echo(self) -> npt.NDArray:
         first_gate_with_data = np.argmin(self.z.mask.all(axis=0))
         gate_number = first_gate_with_data + 3
         threshold = {"z": 3, "v": 0, "ldr": -15}
@@ -132,10 +135,10 @@ class ClassData:
 
 def _find_clutter(
     v: np.ma.MaskedArray,
-    is_rain: np.ndarray,
+    is_rain: npt.NDArray,
     n_gates: int = 10,
     v_lim: float = 0.05,
-) -> np.ndarray:
+) -> npt.NDArray:
     """Estimates clutter from doppler velocity.
 
     Args:

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/disdrometer.py

@@ -1,8 +1,10 @@
 """Mwr module, containing the :class:`Mwr` class."""
 
 import logging
+from os import PathLike
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy.interpolate import interp1d
 
@@ -20,11 +22,11 @@ class Disdrometer(DataSource):
 
     """
 
-    def __init__(self, full_path: str):
+    def __init__(self, full_path: str | PathLike) -> None:
         super().__init__(full_path)
         self._init_rainfall_rate()
 
-    def interpolate_to_grid(self, time_grid: np.ndarray) -> None:
+    def interpolate_to_grid(self, time_grid: npt.NDArray) -> None:
         for key, array in self.data.items():
             self.data[key].data = self._interpolate(array.data, time_grid)
 
@@ -36,7 +38,7 @@ class Disdrometer(DataSource):
                 raise DisdrometerDataError(msg)
             self.append_data(self.dataset.variables[key][:], key)
 
-    def _interpolate(self, y: ma.MaskedArray, x_new: np.ndarray) -> np.ndarray:
+    def _interpolate(self, y: ma.MaskedArray, x_new: npt.NDArray) -> npt.NDArray:
         time = self.time
         mask = ma.getmask(y)
         if mask is not ma.nomask:

{cloudnetpy-1.80.8 → cloudnetpy-1.81.0}/cloudnetpy/categorize/droplet.py

@@ -1,6 +1,7 @@
 """This module has functions for liquid layer detection."""
 
 import numpy as np
+import numpy.typing as npt
 import scipy.signal
 from numpy import ma
 
@@ -11,10 +12,10 @@ from cloudnetpy.categorize.containers import ClassData
 
 def correct_liquid_top(
     obs: ClassData,
-    is_liquid: np.ndarray,
-    is_freezing: np.ndarray,
+    is_liquid: npt.NDArray,
+    is_freezing: npt.NDArray,
     limit: float = 200,
-) -> np.ndarray:
+) -> npt.NDArray:
     """Corrects lidar detected liquid cloud top using radar data.
 
     Args:
@@ -43,7 +44,7 @@ def correct_liquid_top(
     return is_liquid_corrected
 
 
-def _find_ind_above_top(is_freezing_from_peak: np.ndarray, top_above: int) -> int:
+def _find_ind_above_top(is_freezing_from_peak: npt.NDArray, top_above: int) -> int:
     first_point_below_zero = np.where(is_freezing_from_peak)[0][0]
     ind = first_point_below_zero + top_above
     return min(len(is_freezing_from_peak) - 1, ind)
@@ -57,7 +58,7 @@ def find_liquid(
     min_top_der: float = 1e-7,
     min_lwp: float = 0,
     min_alt: float = 100,
-) -> np.ndarray:
+) -> npt.NDArray:
     """Estimate liquid layers from SNR-screened attenuated backscatter.
 
     Args:
@@ -121,7 +122,7 @@ def find_liquid(
     return is_liquid
 
 
-def ind_base(dprof: np.ndarray, ind_peak: int, dist: int, lim: float) -> int:
+def ind_base(dprof: npt.NDArray, ind_peak: int, dist: int, lim: float) -> int:
     """Finds base index of a peak in profile.
 
     Return the lowermost index of profile where 1st order differences
@@ -186,7 +187,9 @@ def ind_base(dprof: np.ndarray, ind_peak: int, dist: int, lim: float) -> int:
     return start + np.where(diffs > diffs[mind] / lim)[0][0]
 
 
-def ind_top(dprof: np.ndarray, ind_peak: int, nprof: int, dist: int, lim: float) -> int:
+def ind_top(
+    dprof: npt.NDArray, ind_peak: int, nprof: int, dist: int, lim: float
+) -> int:
     """Finds top index of a peak in profile.
 
     Return the uppermost index of profile where 1st order differences
@@ -222,7 +225,7 @@ def ind_top(dprof: np.ndarray, ind_peak: int, nprof: int, dist: int, lim: float)
     return ind_peak + np.where(diffs < diffs[mind] / lim)[0][-1] + 1
 
 
-def interpolate_lwp(obs: ClassData) -> np.ndarray:
+def interpolate_lwp(obs: ClassData) -> npt.NDArray:
     """Linear interpolation of liquid water path to fill masked values.
 
     Args:
@@ -238,7 +241,7 @@ def interpolate_lwp(obs: ClassData) -> np.ndarray:
     return np.interp(obs.time, obs.time[ind], obs.lwp[ind])
 
 
-def _find_strong_peaks(data: np.ndarray, threshold: float) -> tuple:
+def _find_strong_peaks(data: npt.NDArray, threshold: float) -> tuple:
     """Finds local maximums from data (greater than *threshold*)."""
     peaks = scipy.signal.argrelextrema(data, np.greater, order=4, axis=1)
     strong_peaks = np.where(data[peaks] > threshold)