cloudnetpy 1.55.20__py3-none-any.whl → 1.55.22__py3-none-any.whl

cloudnetpy/utils.py

@@ -1,12 +1,13 @@
-""" This module contains general helper functions. """
+"""This module contains general helper functions."""
 import datetime
 import logging
 import os
 import re
 import uuid
 import warnings
+from collections.abc import Iterator
 from datetime import timezone
-from typing import Final, Iterator
+from typing import Literal
 
 import netCDF4
 import numpy as np
@@ -14,31 +15,31 @@ from numpy import ma
 from scipy import ndimage, stats
 from scipy.interpolate import RectBivariateSpline, RegularGridInterpolator, griddata
 
+from cloudnetpy.constants import SEC_IN_DAY, SEC_IN_HOUR, SEC_IN_MINUTE
 from cloudnetpy.exceptions import ValidTimeStampError
 
 Epoch = tuple[int, int, int]
 Date = tuple[str, str, str]
 
-SECONDS_PER_MINUTE: Final = 60
-SECONDS_PER_HOUR: Final = 3600
-SECONDS_PER_DAY: Final = 86400
-
 
 def seconds2hours(time_in_seconds: np.ndarray) -> np.ndarray:
     """Converts seconds since some epoch to fraction hour.
 
     Args:
+    ----
         time_in_seconds: 1-D array of seconds since some epoch that starts on midnight.
 
     Returns:
+    -------
         Time as fraction hour.
 
     Notes:
+    -----
         Excludes leap seconds.
 
     """
-    seconds_since_midnight = np.mod(time_in_seconds, SECONDS_PER_DAY)
-    fraction_hour = seconds_since_midnight / SECONDS_PER_HOUR
+    seconds_since_midnight = np.mod(time_in_seconds, SEC_IN_DAY)
+    fraction_hour = seconds_since_midnight / SEC_IN_HOUR
     if fraction_hour[-1] == 0:
         fraction_hour[-1] = 24
     return fraction_hour
@@ -48,16 +49,18 @@ def seconds2time(time_in_seconds: float) -> list:
     """Converts seconds since some epoch to time of day.
 
     Args:
+    ----
         time_in_seconds: seconds since some epoch.
 
     Returns:
+    -------
         list: [hours, minutes, seconds] formatted as '05' etc.
 
     """
-    seconds_since_midnight = np.mod(time_in_seconds, SECONDS_PER_DAY)
-    hours = seconds_since_midnight // SECONDS_PER_HOUR
-    minutes = seconds_since_midnight % SECONDS_PER_HOUR // SECONDS_PER_MINUTE
-    seconds = seconds_since_midnight % SECONDS_PER_MINUTE
+    seconds_since_midnight = np.mod(time_in_seconds, SEC_IN_DAY)
+    hours = seconds_since_midnight // SEC_IN_HOUR
+    minutes = seconds_since_midnight % SEC_IN_HOUR // SEC_IN_MINUTE
+    seconds = seconds_since_midnight % SEC_IN_MINUTE
     time = [hours, minutes, seconds]
     return [str(t).zfill(2) for t in time]
 
@@ -66,19 +69,21 @@ def seconds2date(time_in_seconds: float, epoch: Epoch = (2001, 1, 1)) -> list:
     """Converts seconds since some epoch to datetime (UTC).
 
     Args:
+    ----
         time_in_seconds: Seconds since some epoch.
         epoch: Epoch, default is (2001, 1, 1) (UTC).
 
     Returns:
+    -------
         [year, month, day, hours, minutes, seconds] formatted as '05' etc (UTC).
 
     """
     epoch_in_seconds = datetime.datetime.timestamp(
-        datetime.datetime(*epoch, tzinfo=timezone.utc)
+        datetime.datetime(*epoch, tzinfo=timezone.utc),
     )
     timestamp = time_in_seconds + epoch_in_seconds
     return (
-        datetime.datetime.utcfromtimestamp(timestamp)
+        datetime.datetime.fromtimestamp(timestamp, tz=datetime.timezone.utc)
         .strftime("%Y %m %d %H %M %S")
         .split()
     )
@@ -89,7 +94,7 @@ def datetime2decimal_hours(data: np.ndarray | list) -> np.ndarray:
     output = []
     for timestamp in data:
         t = timestamp.time()
-        decimal_hours = t.hour + t.minute / 60 + t.second / 3600
+        decimal_hours = t.hour + t.minute / SEC_IN_MINUTE + t.second / SEC_IN_HOUR
         output.append(decimal_hours)
     return np.array(output)
 
@@ -101,18 +106,22 @@ def time_grid(time_step: int = 30) -> np.ndarray:
     resolution (in seconds).
 
     Args:
+    ----
         time_step: Time resolution in seconds, greater than 1. Default is 30.
 
     Returns:
+    -------
         Time vector between 0 and 24.
 
     Raises:
+    ------
         ValueError: Bad resolution as input.
 
     """
     if time_step < 1:
-        raise ValueError("Time resolution should be >= 1 seconds")
-    half_step = time_step / SECONDS_PER_HOUR / 2
+        msg = "Time resolution should be >= 1 seconds"
+        raise ValueError(msg)
+    half_step = time_step / SEC_IN_HOUR / 2
     return np.arange(half_step, 24 + half_step, half_step * 2)
 
 
@@ -120,12 +129,15 @@ def binvec(x: np.ndarray | list) -> np.ndarray:
     """Converts 1-D center points to bins with even spacing.
 
     Args:
+    ----
         x: 1-D array of N real values.
 
     Returns:
+    -------
         ndarray: N + 1 edge values.
 
     Examples:
+    --------
         >>> binvec([1, 2, 3])
             [0.5, 1.5, 2.5, 3.5]
 
@@ -145,6 +157,7 @@ def rebin_2d(
     """Rebins 2-D data in one dimension.
 
     Args:
+    ----
         x_in: 1-D array with shape (n,).
         array: 2-D input data with shape (n, m).
         x_new: 1-D target vector (center points) with shape (N,).
@@ -153,9 +166,11 @@ def rebin_2d(
         n_min: Minimum number of points to have good statistics in a bin. Default is 1.
 
     Returns:
+    -------
         tuple: Rebinned data with shape (N, m) and indices of bins without enough data.
 
     Notes:
+    -----
         0-values are masked in the returned array.
 
     """
@@ -166,7 +181,10 @@ def rebin_2d(
         mask = ~values.mask
         if ma.any(values[mask]):
             result[:, ind], _, _ = stats.binned_statistic(
-                x_in[mask], values[mask], statistic=statistic, bins=edges
+                x_in[mask],
+                values[mask],
+                statistic=statistic,
+                bins=edges,
             )
     result[~np.isfinite(result)] = 0
     masked_result = ma.masked_equal(result, 0)
@@ -179,7 +197,7 @@ def rebin_2d(
             masked_result[ind, :] = ma.masked
             empty_indices.append(ind)
     if len(empty_indices) > 0:
-        logging.debug(f"No radar data in {len(empty_indices)} bins")
+        logging.debug("No radar data in %s bins", len(empty_indices))
 
     return masked_result, empty_indices
 
@@ -193,6 +211,7 @@ def rebin_1d(
     """Rebins 1D array.
 
     Args:
+    ----
         x_in: 1-D array with shape (n,).
         array: 1-D input data with shape (m,).
         x_new: 1-D target vector (center points) with shape (N,).
@@ -200,16 +219,20 @@ def rebin_1d(
             Default is 'mean'.
 
     Returns:
-        Rebinned data with shape (N,).
+    -------
+        Re-binned data with shape (N,).
 
     """
     edges = binvec(x_new)
     result = np.zeros(len(x_new))
     array_screened = ma.masked_invalid(array, copy=True)  # data may contain nan-values
-    mask = ~array_screened.mask  # pylint: disable=E1101
+    mask = ~array_screened.mask
     if ma.any(array_screened[mask]):
         result, _, _ = stats.binned_statistic(
-            x_in[mask], array_screened[mask], statistic=statistic, bins=edges
+            x_in[mask],
+            array_screened[mask],
+            statistic=statistic,
+            bins=edges,
         )
     result[~np.isfinite(result)] = 0
     return ma.masked_equal(result, 0)
@@ -219,12 +242,15 @@ def filter_isolated_pixels(array: np.ndarray) -> np.ndarray:
     """From a 2D boolean array, remove completely isolated single cells.
 
     Args:
+    ----
         array: 2-D boolean array containing isolated values.
 
     Returns:
+    -------
         Cleaned array.
 
     Examples:
+    --------
         >>> filter_isolated_pixels([[0, 0, 0], [0, 1, 0], [0, 0, 0]])
             array([[0, 0, 0],
                    [0, 0, 0],
@@ -239,15 +265,19 @@ def filter_x_pixels(array: np.ndarray) -> np.ndarray:
     """From a 2D boolean array, remove cells isolated in x-direction.
 
     Args:
+    ----
         array: 2-D boolean array containing isolated pixels in x-direction.
 
     Returns:
+    -------
         Cleaned array.
 
     Notes:
+    -----
         Stronger cleaning than `filter_isolated_pixels()`
 
     Examples:
+    --------
         >>> filter_x_pixels([[1, 0, 0], [0, 1, 0], [0, 1, 1]])
             array([[0, 0, 0],
                    [0, 1, 0],
@@ -268,30 +298,36 @@ def _filter(array: np.ndarray, structure: np.ndarray) -> np.ndarray:
 
 
 def isbit(array: np.ndarray, nth_bit: int) -> np.ndarray:
-    """Tests if nth bit (0,1,2..) is set.
+    """Tests if nth bit (0,1,2,...) is set.
 
     Args:
+    ----
         array: Integer array.
         nth_bit: Investigated bit.
 
     Returns:
+    -------
         Boolean array denoting values where nth_bit is set.
 
     Raises:
+    ------
         ValueError: negative bit as input.
 
     Examples:
+    --------
         >>> isbit(4, 1)
             False
         >>> isbit(4, 2)
             True
 
-    See also:
+    See Also:
+    --------
         utils.setbit()
 
     """
     if nth_bit < 0:
-        raise ValueError("Negative bit number")
+        msg = "Negative bit number"
+        raise ValueError(msg)
     mask = 1 << nth_bit
     return array & mask > 0
 
@@ -300,27 +336,33 @@ def setbit(array: np.ndarray, nth_bit: int) -> np.ndarray:
     """Sets nth bit (0, 1, 2, ...) on number.
 
     Args:
+    ----
         array: Integer array.
         nth_bit: Bit to be set.
 
     Returns:
+    -------
         Integer where nth bit is set.
 
     Raises:
+    ------
         ValueError: negative bit as input.
 
     Examples:
+    --------
         >>> setbit(1, 1)
             3
         >>> setbit(0, 2)
             4
 
-    See also:
+    See Also:
+    --------
         utils.isbit()
 
     """
     if nth_bit < 0:
-        raise ValueError("Negative bit number")
+        msg = "Negative bit number"
+        raise ValueError(msg)
     mask = 1 << nth_bit
     array |= mask
     return array
@@ -336,6 +378,7 @@ def interpolate_2d(
     """Linear interpolation of gridded 2d data.
 
     Args:
+    ----
         x: 1-D array.
         y: 1-D array.
         z: 2-D array at points (x, y).
@@ -343,9 +386,11 @@ def interpolate_2d(
         y_new: 1-D array.
 
     Returns:
+    -------
         Interpolated data.
 
     Notes:
+    -----
         Does not work with nans. Ignores mask of masked data. Does not extrapolate.
 
     """
@@ -363,6 +408,7 @@ def interpolate_2d_mask(
     """2D linear interpolation preserving the mask.
 
     Args:
+    ----
         x: 1D array, x-coordinates.
         y: 1D array, y-coordinates.
         z: 2D masked array, data values.
@@ -370,31 +416,35 @@ def interpolate_2d_mask(
         y_new: 1D array, new y-coordinates.
 
     Returns:
+    -------
         Interpolated 2D masked array.
 
     Notes:
+    -----
         Points outside the original range will be nans (and masked). Uses linear
         interpolation. Input data may contain nan-values.
 
     """
-    z = ma.array(ma.masked_invalid(z, copy=True))  # ma.array() to avoid pylint nag
+    z = ma.array(ma.masked_invalid(z, copy=True))
     # Interpolate ignoring masked values:
-    valid_points = np.logical_not(z.mask)  # ~z.mask causes pylint nag
+    valid_points = np.logical_not(z.mask)
     xx, yy = np.meshgrid(y, x)
     x_valid = xx[valid_points]
     y_valid = yy[valid_points]
     z_valid = z[valid_points]
     xx_new, yy_new = np.meshgrid(y_new, x_new)
     data = griddata(
-        (x_valid, y_valid), z_valid.ravel(), (xx_new, yy_new), method="linear"
+        (x_valid, y_valid),
+        z_valid.ravel(),
+        (xx_new, yy_new),
+        method="linear",
     )
     # Preserve mask:
     mask_fun = RectBivariateSpline(x, y, z.mask[:], kx=1, ky=1)
     mask = mask_fun(x_new, y_new)
     mask[mask < 0.5] = 0
     masked_array = ma.array(data, mask=mask.astype(bool))
-    masked_array = ma.masked_invalid(masked_array)
-    return masked_array
+    return ma.masked_invalid(masked_array)
 
 
 def interpolate_2d_nearest(
@@ -407,6 +457,7 @@ def interpolate_2d_nearest(
     """2D nearest neighbor interpolation preserving mask.
 
     Args:
+    ----
         x: 1D array, x-coordinates.
         y: 1D array, y-coordinates.
         z: 2D masked array, data values.
@@ -414,9 +465,11 @@ def interpolate_2d_nearest(
         y_new: 1D array, new y-coordinates.
 
     Returns:
+    -------
         Interpolated 2D masked array.
 
     Notes:
+    -----
         Points outside the original range will be interpolated but masked.
 
     """
@@ -438,7 +491,7 @@ def calc_relative_error(reference: np.ndarray, array: np.ndarray) -> np.ndarray:
 
 
 def db2lin(array: float | np.ndarray, scale: int = 10) -> np.ndarray:
-    """dB to linear conversion."""
+    """DB to linear conversion."""
     data = array / scale
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", category=RuntimeWarning)
@@ -463,9 +516,11 @@ def l2norm(*args) -> ma.MaskedArray:
     """Returns l2 norm.
 
     Args:
+    ----
        *args: Variable number of data (*array_like*) with the same shape.
 
     Returns:
+    -------
         The l2 norm.
 
     """
@@ -473,16 +528,18 @@ def l2norm(*args) -> ma.MaskedArray:
     for arg in args:
         if isinstance(arg, ma.MaskedArray):
             # Raise only non-masked values, not sure if this is needed...
-            arg = ma.copy(arg)
-            arg[~arg.mask] = arg[~arg.mask] ** 2
+            arg_cpy = ma.copy(arg)
+            arg_cpy[~arg.mask] = arg_cpy[~arg.mask] ** 2
         else:
-            arg = arg**2
-        ss = ss + arg
+            arg_cpy = arg**2
+        ss = ss + arg_cpy
     return ma.sqrt(ss)
 
 
 def l2norm_weighted(
-    values: tuple, overall_scale: float, term_weights: tuple
+    values: tuple,
+    overall_scale: float,
+    term_weights: tuple,
 ) -> ma.MaskedArray:
     """Calculates scaled and weighted Euclidean distance.
 
@@ -491,12 +548,14 @@ def l2norm_weighted(
     for the terms.
 
     Args:
+    ----
         values: Tuple containing the values.
         overall_scale: Scale factor for the calculated Euclidean distance.
         term_weights: Weights for the terms. Must be single float or a list of numbers
             (one per term).
 
     Returns:
+    -------
         Scaled and weighted Euclidean distance.
 
     TODO: Use masked arrays instead of tuples.
@@ -511,58 +570,68 @@ def cumsumr(array: np.ndarray, axis: int = 0) -> np.ndarray:
     """Finds cumulative sum that resets on 0.
 
     Args:
+    ----
         array: Input array.
         axis: Axis where the sum is calculated. Default is 0.
 
     Returns:
+    -------
         Cumulative sum, restarted at 0.
 
     Examples:
+    --------
         >>> x = np.array([0, 0, 1, 1, 0, 0, 0, 1, 1, 1])
         >>> cumsumr(x)
             [0, 0, 1, 2, 0, 0, 0, 1, 2, 3]
 
     """
     cums = array.cumsum(axis=axis)
-    return cums - np.maximum.accumulate(
-        cums * (array == 0), axis=axis
-    )  # pylint: disable=E1101
+    return cums - np.maximum.accumulate(cums * (array == 0), axis=axis)
 
 
 def ffill(array: np.ndarray, value: int = 0) -> np.ndarray:
     """Forward fills an array.
 
     Args:
+    ----
         array: 1-D or 2-D array.
         value: Value to be filled. Default is 0.
 
     Returns:
+    -------
         ndarray: Forward-filled array.
 
     Examples:
+    --------
         >>> x = np.array([0, 5, 0, 0, 2, 0])
         >>> ffill(x)
             [0, 5, 5, 5, 2, 2]
 
     Notes:
+    -----
         Works only in axis=1 direction.
 
     """
     ndims = len(array.shape)
     ran = np.arange(array.shape[ndims - 1])
     idx = np.where((array != value), ran, 0)
-    idx = np.maximum.accumulate(idx, axis=ndims - 1)  # pylint: disable=E1101
+    idx = np.maximum.accumulate(idx, axis=ndims - 1)
     if ndims == 2:
         return array[np.arange(idx.shape[0])[:, None], idx]
     return array[idx]
 
 
 def init(
-    n_vars: int, shape: tuple, dtype: type = float, masked: bool = True
+    n_vars: int,
+    shape: tuple,
+    dtype: type = float,
+    *,
+    masked: bool = True,
 ) -> Iterator[np.ndarray | ma.MaskedArray]:
     """Initializes several numpy arrays.
 
     Args:
+    ----
         n_vars: Number of arrays to be generated.
         shape: Shape of the arrays, e.g. (2, 3).
         dtype: The desired data-type for the arrays, e.g., int. Default is float.
@@ -570,9 +639,11 @@ def init(
             Default is True.
 
     Yields:
+    ------
         Iterator containing the empty arrays.
 
     Examples:
+    --------
         >>> a, b = init(2, (2, 3))
         >>> a
             masked_array(
@@ -593,17 +664,20 @@ def n_elements(array: np.ndarray, dist: float, var: str | None = None) -> int:
     """Returns the number of elements that cover certain distance.
 
     Args:
+    ----
         array: Input array with arbitrary units or time in fraction hour. *x* should
             be evenly spaced or at least close to.
         dist: Distance to be covered. If x is fraction time, *dist* is in minutes.
-            Otherwise *x* and *dist* should have the same units.
+            Otherwise, *x* and *dist* should have the same units.
         var: If 'time', input is fraction hour and distance in minutes, else inputs
             have the same units. Default is None (same units).
 
     Returns:
+    -------
         Number of elements in the input array that cover *dist*.
 
     Examples:
+    --------
         >>> x = np.array([2, 4, 6, 8, 10])
         >>> n_elements(x, 6)
             3
@@ -624,16 +698,17 @@ def n_elements(array: np.ndarray, dist: float, var: str | None = None) -> int:
     """
     n = dist / mdiff(array)
     if var == "time":
-        n = n / 60
+        n = n / SEC_IN_MINUTE
     return int(np.round(n))
 
 
-def isscalar(array) -> bool:
+def isscalar(array: np.ndarray | float | list) -> bool:
     """Tests if input is scalar.
 
     By "scalar" we mean that array has a single value.
 
-    Examples:
+    Examples
+    --------
         >>> isscalar(1)
             True
         >>> isscalar([1])
@@ -645,18 +720,19 @@ def isscalar(array) -> bool:
 
     """
     arr = ma.array(array)
-    if not hasattr(arr, "__len__") or arr.shape == () or len(arr) == 1:
-        return True
-    return False
+    return not hasattr(arr, "__len__") or arr.shape == () or len(arr) == 1
 
 
 def get_time() -> str:
     """Returns current UTC-time."""
-    return f"{datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')} +00:00"
+    t_zone = datetime.timezone.utc
+    form = "%Y-%m-%d %H:%M:%S"
+    return f"{datetime.datetime.now(tz=t_zone).strftime(form)} +00:00"
 
 
 def date_range(
-    start_date: datetime.date, end_date: datetime.date
+    start_date: datetime.date,
+    end_date: datetime.date,
 ) -> Iterator[datetime.date]:
     """Returns range between two dates (datetimes)."""
     for n in range(int((end_date - start_date).days)):
@@ -672,9 +748,11 @@ def get_wl_band(radar_frequency: float) -> int:
     """Returns integer corresponding to radar frequency.
 
     Args:
+    ----
         radar_frequency: Radar frequency (GHz).
 
     Returns:
+    -------
         0 = 35GHz radar, 1 = 94Ghz radar.
 
     """
@@ -689,7 +767,8 @@ def get_frequency(wl_band: int) -> str:
 def transpose(data: np.ndarray) -> np.ndarray:
     """Transposes numpy array of (n, ) to (n, 1)."""
     if data.ndim != 1 or len(data) <= 1:
-        raise ValueError("Invalid input array shape")
+        msg = "Invalid input array shape"
+        raise ValueError(msg)
     return data[:, np.newaxis]
 
 
@@ -697,10 +776,12 @@ def del_dict_keys(data: dict, keys: tuple | list) -> dict:
     """Deletes multiple keys from dictionary.
 
     Args:
+    ----
         data: A dictionary.
         keys: Keys to be deleted.
 
     Returns:
+    -------
         Dictionary without the deleted keys.
 
     """
@@ -712,11 +793,16 @@ def del_dict_keys(data: dict, keys: tuple | list) -> dict:
 
 
 def array_to_probability(
-    array: np.ndarray, loc: float, scale: float, invert: bool = False
+    array: np.ndarray,
+    loc: float,
+    scale: float,
+    *,
+    invert: bool = False,
 ) -> np.ndarray:
     """Converts continuous variable into 0-1 probability.
 
     Args:
+    ----
         array: Numpy array.
         loc: Center of the distribution. Values smaller than this will have small
             probability. Values greater than this will have large probability.
@@ -726,6 +812,7 @@ def array_to_probability(
             Default is False.
 
     Returns:
+    -------
         Probability with the same shape as the input data.
 
     """
@@ -743,13 +830,16 @@ def range_to_height(range_los: np.ndarray, tilt_angle: float) -> np.ndarray:
     """Converts distances from a tilted instrument to height above the ground.
 
     Args:
+    ----
         range_los: Distances towards the line of sign from the instrument.
         tilt_angle: Angle in degrees from the zenith (0 = zenith).
 
     Returns:
+    -------
         Altitudes of the LOS points.
 
     Notes:
+    -----
         Uses plane parallel Earth approximation.
 
     """
@@ -776,9 +866,7 @@ def get_sorted_filenames(file_path: str, extension: str) -> list:
     extension = extension.lower()
     all_files = os.listdir(file_path)
     files = [
-        "/".join((file_path, file))
-        for file in all_files
-        if file.lower().endswith(extension)
+        f"{file_path}/{file}" for file in all_files if file.lower().endswith(extension)
     ]
     files.sort()
     return files
@@ -808,7 +896,7 @@ def get_epoch(units: str) -> Epoch:
         except ValueError:
             return fallback
     year, month, day = date_components
-    current_year = datetime.datetime.today().year
+    current_year = datetime.datetime.now(tz=datetime.timezone.utc).year
     if (1900 < year <= current_year) and (0 < month < 13) and (0 < day < 32):
         return year, month, day
     return fallback
@@ -818,14 +906,17 @@ def screen_by_time(data_in: dict, epoch: Epoch, expected_date: str) -> dict:
     """Screen data by time.
 
     Args:
+    ----
         data_in: Dictionary containing at least 'time' key and other numpy arrays.
         epoch: Epoch of the time array, e.g., (1970, 1, 1)
         expected_date: Expected date in yyyy-mm-dd
 
     Returns:
+    -------
         data: Screened and sorted by the time vector.
 
     Notes:
+    -----
         - Requires 'time' key
         - Works for dimensions 1, 2, 3 (time has to be at 0-axis)
         - Does nothing for scalars
@@ -855,17 +946,21 @@ def find_valid_time_indices(time: np.ndarray, epoch: Epoch, expected_date: str)
     """Finds valid time array indices for the given date.
 
     Args:
+    ----
         time: Time in seconds from some epoch.
         epoch: Epoch of the time array, e.g., (1970, 1, 1)
         expected_date: Expected date in yyyy-mm-dd
 
     Returns:
+    -------
         list: Valid indices for the given date in sorted order.
 
     Raises:
+    ------
         RuntimeError: No valid timestamps.
 
     Examples:
+    --------
         >>> time = [1, 5, 1e6, 3]
         >>> find_valid_time_indices(time, (1970, 1, 1) '1970-01-01')
             [0, 3, 2]
@@ -886,6 +981,7 @@ def append_data(data_in: dict, key: str, array: np.ndarray) -> dict:
     """Appends data to a dictionary field (creates the field if not yet present).
 
     Args:
+    ----
         data_in: Dictionary where data will be appended.
         key: Key of the field.
         array: Numpy array to be appended to data_in[key].
@@ -899,19 +995,19 @@ def append_data(data_in: dict, key: str, array: np.ndarray) -> dict:
     return data
 
 
-def edges2mid(data: np.ndarray, reference: str) -> np.ndarray:
+def edges2mid(data: np.ndarray, reference: Literal["upper", "lower"]) -> np.ndarray:
     """Shifts values half bin towards up or down.
 
     Args:
+    ----
         data: 1D numpy array (e.g. range)
         reference: If 'lower', increase values by half bin. If 'upper', decrease values.
 
     Returns:
+    -------
         Shifted values.
 
     """
-    if reference not in ("lower", "upper"):
-        raise ValueError
     gaps = (data[1:] - data[0:-1]) / 2
     if reference == "lower":
         gaps = np.append(gaps, gaps[-1])
@@ -924,32 +1020,37 @@ def get_file_type(filename: str) -> str:
     """Returns cloudnet file type from new and legacy files."""
     with netCDF4.Dataset(filename) as nc:
         if hasattr(nc, "cloudnet_file_type"):
-            file_type = nc.cloudnet_file_type
-            return file_type
+            return nc.cloudnet_file_type
     product = filename.split("_")[-1][:-3]
     if product in ("categorize", "classification", "drizzle"):
         return product
     if product[:3] in ("lwc", "iwc"):
         return product[:3]
-    raise ValueError("Unknown file type")
+    msg = "Unknown file type"
+    raise ValueError(msg)
 
 
-def get_files_with_common_range(files: list) -> list:
+def get_files_with_common_range(filenames: list) -> list:
     """Returns files with the same (most common) number of range gates."""
     n_range = []
-    for file in files:
+    for file in filenames:
         with netCDF4.Dataset(file) as nc:
             n_range.append(len(nc.variables["range"]))
     most_common = np.bincount(n_range).argmax()
-    n_removed = len([n for n in n_range if n != most_common])
-    if n_removed > 0:
-        logging.warning(f"Removing {n_removed} files due to inconsistent height vector")
-    ind = np.where(n_range == most_common)[0]
-    return [file for i, file in enumerate(files) if i in ind]
+    if n_removed := len(filenames) - n_range.count(int(most_common)) > 0:
+        logging.warning(
+            "Removing %s files due to inconsistent height vector", n_removed
+        )
+    return [file for i, file in enumerate(filenames) if n_range[i] == most_common]
 
 
 def is_all_masked(array: np.ndarray) -> bool:
     """Tests if all values are masked."""
-    if ma.isMaskedArray(array) and hasattr(array, "mask"):
-        return array.mask.all()
-    return False
+    return ma.isMaskedArray(array) and hasattr(array, "mask") and array.mask.all()
+
+
+def find_masked_profiles_indices(array: ma.MaskedArray) -> list:
+    """Finds indices of masked profiles in a 2-D array."""
+    non_masked_counts = np.ma.count(array, axis=1)
+    masked_profiles_indices = np.where(non_masked_counts == 0)[0]
+    return list(masked_profiles_indices)