cloudnetpy 1.77.2__py3-none-any.whl → 1.78.1__py3-none-any.whl

cloudnetpy/categorize/insects.py

@@ -83,7 +83,7 @@ def _get_smoothed_v(
     obs: ClassData,
     sigma: tuple[float, float] = (5, 5),
 ) -> ma.MaskedArray:
-    smoothed_v = gaussian_filter(obs.v, sigma)
+    smoothed_v = gaussian_filter(obs.v.filled(0), sigma)
     return ma.masked_where(obs.v.mask, smoothed_v)
 
 

cloudnetpy/categorize/radar.py

@@ -24,8 +24,6 @@ class Radar(DataSource):
         folding_velocity (float): Radar's folding velocity (m/s).
         location (str): Location of the radar, copied from the global attribute
             `location` of the input file.
-        sequence_indices (list): Indices denoting the different altitude
-            regimes of the radar.
         source_type (str): Type of the radar, copied from the global attribute
             `source` of the *radar_file*. Can be free form string but must
             include either 'rpg' or 'mira' denoting one of the two supported
@@ -39,21 +37,17 @@ class Radar(DataSource):
     def __init__(self, full_path: str):
         super().__init__(full_path, radar=True)
         self.radar_frequency = float(self.getvar("radar_frequency"))
-        self.folding_velocity = self._get_folding_velocity()
-        self.sequence_indices = self._get_sequence_indices()
         self.location = getattr(self.dataset, "location", "")
         self.source_type = getattr(self.dataset, "source", "")
         self.height: np.ndarray
         self.altitude: float
         self._init_data()
-        self._init_sigma_v()
-        self._get_folding_velocity_full()
 
     def rebin_to_grid(self, time_new: np.ndarray) -> list:
-        """Rebins radar data in time using mean.
+        """Rebins radar data in time.
 
         Args:
-            time_new: Target time array as fraction hour. Updates *time* attribute.
+            time_new: Target time array as fraction hour.
 
         """
         bad_time_indices = []
@@ -64,21 +58,25 @@ class Radar(DataSource):
                     bad_time_indices = array.rebin_data(self.time, time_new)
                     array.lin2db()
                 case "v":
-                    array.rebin_velocity(
-                        self.time,
+                    array.data = self._rebin_velocity(
+                        array.data,
                         time_new,
-                        self.folding_velocity,
-                        self.sequence_indices,
                     )
                 case "v_sigma":
-                    array.calc_linear_std(self.time, time_new)
+                    array.data, _ = utils.rebin_2d(
+                        self.time,
+                        array.data,
+                        time_new,
+                        "std",
+                        mask_zeros=True,
+                    )
                 case "width":
                     array.rebin_data(self.time, time_new)
                 case "rainfall_rate":
-                    array.rebin_data(self.time, time_new, mask_zeros=False)
+                    array.rebin_data(self.time, time_new)
                 case _:
                     continue
-        return bad_time_indices
+        return list(bad_time_indices)
 
     def remove_incomplete_pixels(self) -> None:
         """Mask radar pixels where one or more required quantities are missing.
@@ -337,63 +335,88 @@ class Radar(DataSource):
 
     def _init_data(self) -> None:
         self.append_data(self.getvar("Zh"), "Z", units="dBZ")
-        for key in ("v", "ldr", "width", "sldr", "rainfall_rate"):
-            try:
-                self._variables_to_cloudnet_arrays((key,))
-            except KeyError:
-                continue
-
-    def _init_sigma_v(self) -> None:
-        """Initializes std of the velocity field. The std will be calculated
-        later when re-binning the data.
-        """
         self.append_data(self.getvar("v"), "v_sigma")
+        for key in ("v", "ldr", "width", "sldr", "rainfall_rate", "nyquist_velocity"):
+            if key in self.dataset.variables:
+                data = self.dataset.variables[key]
+                self.append_data(data, key)
 
-    def _get_sequence_indices(self) -> list:
-        """Mira has only one sequence and one folding velocity. RPG has
-        several sequences with different folding velocities.
-        """
-        if self.height is None:
-            msg = "Height not found in the input file"
-            raise RuntimeError(msg)
-        all_indices = np.arange(len(self.height))
-        if not utils.isscalar(self.folding_velocity):
-            starting_indices = self.getvar("chirp_start_indices")
-            return np.split(all_indices, starting_indices[1:])
-        return [all_indices]
-
-    def _get_folding_velocity(self) -> np.ndarray | float:
+    def _rebin_velocity(
+        self,
+        data: np.ndarray,
+        time_new: np.ndarray,
+    ) -> np.ndarray:
+        """Rebins Doppler velocity in polar coordinates."""
+        folding_velocity = self._get_expanded_folding_velocity()
+        # with the new shape (maximum value in every bin)
+        max_folding_binned, _ = utils.rebin_2d(
+            self.time,
+            folding_velocity,
+            time_new,
+            "max",
+        )
+        # store this in the file
+        self.append_data(max_folding_binned, "nyquist_velocity")
+        # with original shape (repeat maximum value for each point in every bin)
+        max_folding_full, _ = utils.rebin_2d(
+            self.time,
+            folding_velocity,
+            time_new,
+            "max",
+            keepdim=True,
+        )
+        data_scaled = data * (np.pi / max_folding_full)
+        vel_x = ma.cos(data_scaled)
+        vel_y = ma.sin(data_scaled)
+        vel_x_mean, _ = utils.rebin_2d(self.time, vel_x, time_new)
+        vel_y_mean, _ = utils.rebin_2d(self.time, vel_y, time_new)
+        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:
         if "nyquist_velocity" in self.dataset.variables:
-            return self.getvar("nyquist_velocity")
-        if "prf" in self.dataset.variables:
+            fvel = self.getvar("nyquist_velocity")
+        elif "prf" in self.dataset.variables:
             prf = self.getvar("prf")
-            return _prf_to_folding_velocity(prf, self.radar_frequency)
-        msg = "Unable to determine folding velocity"
-        raise RuntimeError(msg)
-
-    def _get_folding_velocity_full(self) -> None:
-        folding_velocity: list | np.ndarray = []
-        if utils.isscalar(self.folding_velocity):
-            folding_velocity = np.repeat(
-                self.folding_velocity,
-                len(self.sequence_indices[0]),
-            )
+            fvel = _prf_to_folding_velocity(prf, self.radar_frequency)
         else:
-            folding_velocity = list(folding_velocity)
-            self.folding_velocity = np.array(self.folding_velocity)
-            for indices, velocity in zip(
-                self.sequence_indices,
-                self.folding_velocity,
-                strict=True,
-            ):
-                folding_velocity.append(np.repeat(velocity, len(indices)))
-            folding_velocity = np.hstack(folding_velocity)
-        self.append_data(folding_velocity, "nyquist_velocity")
-
-
-def _prf_to_folding_velocity(prf: np.ndarray, radar_frequency: float) -> float:
+            msg = "Unable to determine folding velocity"
+            raise RuntimeError(msg)
+
+        n_time = self.getvar("time").size
+        n_height = self.height.size
+
+        if fvel.shape == (n_time, n_height):
+            # Folding velocity is already expanded in radar file
+            # Not yet in current files
+            return fvel
+        if utils.isscalar(fvel):
+            # e.g. MIRA
+            return np.broadcast_to(fvel, (n_time, n_height))
+
+        # RPG radars have chirp segments
+        starts = self.getvar("chirp_start_indices")
+        n_seg = starts.size if starts.ndim == 1 else starts.shape[1]
+
+        starts = np.broadcast_to(starts, (n_time, n_seg))
+        fvel = np.broadcast_to(fvel, (n_time, n_seg))
+
+        # Indices should start from zero (first range gate)
+        # In pre-processed RV Meteor files the first index is 1, so normalize:
+        # Normalize starts so indices begin from zero
+        first_values = starts[:, [0]]
+        if not np.all(np.isin(first_values, [0, 1])):
+            msg = "First value of chirp_start_indices must be 0 or 1"
+            raise ValueError(msg)
+        starts = starts - first_values
+
+        chirp_size = np.diff(starts, append=n_height)
+        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:
     ghz_to_hz = 1e9
     if len(prf) != 1:
         msg = "Unable to determine folding velocity"
         raise RuntimeError(msg)
-    return float(prf[0] * constants.c / (4 * radar_frequency * ghz_to_hz))
+    return prf[0] * constants.c / (4 * radar_frequency * ghz_to_hz)

cloudnetpy/cloudnetarray.py

@@ -1,6 +1,5 @@
 """CloudnetArray class."""
 
-import math
 from collections.abc import Sequence
 
 import netCDF4
@@ -58,29 +57,22 @@ class CloudnetArray:
         """Masks data from given indices."""
         self.data[ind] = ma.masked
 
-    def rebin_data(
-        self, time: np.ndarray, time_new: np.ndarray, *, mask_zeros: bool = True
-    ) -> list:
+    def rebin_data(self, time: np.ndarray, time_new: np.ndarray) -> np.ndarray:
         """Rebins `data` in time.
 
         Args:
             time: 1D time array.
             time_new: 1D new time array.
-            mask_zeros: Whether to mask 0 values in the returned array. Default is True.
 
         Returns:
             Time indices without data.
 
         """
         if self.data.ndim == 1:
-            self.data = utils.rebin_1d(time, self.data, time_new, mask_zeros=mask_zeros)
-            bad_indices = list(np.where(self.data == ma.masked)[0])
+            self.data = utils.rebin_1d(time, self.data, time_new)
+            bad_indices = np.nonzero(self.data.mask)[0]
         else:
-            if not isinstance(self.data, ma.MaskedArray):
-                self.data = ma.masked_array(self.data)
-            self.data, bad_indices = utils.rebin_2d(
-                time, self.data, time_new, mask_zeros=mask_zeros
-            )
+            self.data, bad_indices = utils.rebin_2d(time, self.data, time_new)
         return bad_indices
 
     def fetch_attributes(self) -> list:
@@ -108,6 +100,21 @@ class CloudnetArray:
             if data:
                 setattr(self, key, data)
 
+    def filter_isolated_pixels(self) -> None:
+        """Filters hot pixels from radar data."""
+        self._filter(utils.filter_isolated_pixels)
+
+    def filter_vertical_stripes(self) -> None:
+        """Filters vertical artifacts from radar data."""
+        self._filter(utils.filter_x_pixels)
+
+    def _filter(self, fun) -> 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:
         if isinstance(self.variable, netCDF4.Variable):
             return self.variable[:]
@@ -139,73 +146,3 @@ class CloudnetArray:
 
     def __getitem__(self, ind: tuple) -> np.ndarray:
         return self.data[ind]
-
-    def filter_isolated_pixels(self) -> None:
-        """Filters hot pixels from radar data."""
-        self._filter(utils.filter_isolated_pixels)
-
-    def filter_vertical_stripes(self) -> None:
-        """Filters vertical artifacts from radar data."""
-        self._filter(utils.filter_x_pixels)
-
-    def _filter(self, fun) -> 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 calc_linear_std(self, time: np.ndarray, time_new: np.ndarray) -> None:
-        """Calculates std of radar velocity.
-
-        Args:
-            time: 1D time array.
-            time_new: 1D new time array.
-
-        Notes:
-            The result is masked if the bin contains masked values.
-        """
-        data_as_float = self.data.astype(float)
-        data_as_float = ma.masked_array(data_as_float)
-        self.data, _ = utils.rebin_2d(time, data_as_float, time_new, "std")
-
-    def rebin_velocity(
-        self,
-        time: np.ndarray,
-        time_new: np.ndarray,
-        folding_velocity: float | np.ndarray,
-        sequence_indices: list,
-    ) -> None:
-        """Rebins Doppler velocity in polar coordinates.
-
-        Args:
-            time: 1D time array.
-            time_new: 1D new time array.
-            folding_velocity: Folding velocity (m/s). Can be a float when
-                it's the same for all altitudes, or np.ndarray when it
-                matches difference altitude regions (defined in `sequence_indices`).
-            sequence_indices: List containing indices of different folding regions,
-                e.g. [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10]].
-
-        """
-
-        def _get_scaled_vfold() -> np.ndarray:
-            vfold_scaled = math.pi / folding_velocity
-            if isinstance(vfold_scaled, float):
-                vfold_scaled = np.array([float(vfold_scaled)])
-            return vfold_scaled
-
-        def _scale_by_vfold(data_in: np.ndarray, fun) -> np.ndarray:
-            data_out = ma.copy(data_in)
-            for i, ind in enumerate(sequence_indices):
-                data_out[:, ind] = fun(data_in[:, ind], folding_velocity_scaled[i])
-            return data_out
-
-        folding_velocity_scaled = _get_scaled_vfold()
-        data_scaled = _scale_by_vfold(self.data, np.multiply)
-        vel_x = ma.cos(data_scaled)
-        vel_y = ma.sin(data_scaled)
-        vel_x_mean, _ = utils.rebin_2d(time, vel_x, time_new)
-        vel_y_mean, _ = utils.rebin_2d(time, vel_y, time_new)
-        mean_vel_scaled = np.arctan2(vel_y_mean, vel_x_mean)
-        self.data = _scale_by_vfold(mean_vel_scaled, np.divide)

cloudnetpy/concat_lib.py

@@ -9,9 +9,9 @@ from typing import Literal
 
 import netCDF4
 import numpy as np
+from numpy import ma
 
 from cloudnetpy import utils
-from cloudnetpy.exceptions import InconsistentDataError
 
 
 def truncate_netcdf_file(
@@ -89,7 +89,7 @@ def concatenate_files(
     variables: list | None = None,
     new_attributes: dict | None = None,
     ignore: list | None = None,
-    allow_difference: list | None = None,
+    interp_dimension: str = "range",
 ) -> list:
     """Concatenate netCDF files in one dimension.
 
@@ -101,22 +101,21 @@ def concatenate_files(
             Default is None when all variables with 'concat_dimension' will be saved.
         new_attributes: Optional new global attributes as {'attribute_name': value}.
         ignore: List of variables to be ignored.
-        allow_difference: Names of scalar variables that can differ from one file to
-            another (value from the first file is saved).
+        interp_dimension: Dimension name for interpolation if the dimensions
+            are not the same.
 
     Returns:
         List of filenames that were successfully concatenated.
 
     Notes:
-        Arrays without 'concat_dimension', scalars, and global attributes will be taken
-        from the first file. Groups, possibly present in a NETCDF4 formatted file,
-        are ignored.
+        Arrays without 'concat_dimension' and scalars are expanded to the
+        concat_dimension. Global attributes are taken from the first file.
+        Groups, possibly present in a NETCDF4 formatted file, are ignored.
 
     """
-    with _Concat(filenames, output_file, concat_dimension) as concat:
-        concat.get_common_variables()
+    with _Concat(filenames, output_file, concat_dimension, interp_dimension) as concat:
         concat.create_global_attributes(new_attributes)
-        return concat.concat_data(variables, ignore, allow_difference)
+        return concat.concat_data(variables, ignore)
 
 
 class _Concat:
@@ -127,19 +126,14 @@ class _Concat:
         filenames: Iterable[PathLike | str],
         output_file: str,
         concat_dimension: str = "time",
+        interp_dim: str = "range",
     ):
         self.filenames = sorted(map(Path, filenames), key=lambda f: f.name)
         self.concat_dimension = concat_dimension
+        self.interp_dim = interp_dim
         self.first_filename = self.filenames[0]
         self.first_file = netCDF4.Dataset(self.first_filename)
         self.concatenated_file = self._init_output_file(output_file)
-        self.common_variables = set()
-
-    def get_common_variables(self) -> None:
-        """Finds variables which should have the same values in all files."""
-        for key, value in self.first_file.variables.items():
-            if self.concat_dimension not in value.dimensions:
-                self.common_variables.add(key)
 
     def create_global_attributes(self, new_attributes: dict | None) -> None:
         """Copies global attributes from one of the source files."""
@@ -150,17 +144,16 @@ class _Concat:
 
     def concat_data(
         self,
-        variables: list | None,
-        ignore: list | None,
-        allow_vary: list | None,
+        keep: list | None = None,
+        ignore: list | None = None,
     ) -> list:
         """Concatenates data arrays."""
-        self._write_initial_data(variables, ignore)
+        self._write_initial_data(keep, ignore)
         output = [self.first_filename]
         if len(self.filenames) > 1:
             for filename in self.filenames[1:]:
                 try:
-                    self._append_data(filename, allow_vary)
+                    self._append_data(filename)
                 except RuntimeError as e:
                     if "NetCDF: HDF error" in str(e):
                         msg = f"Caught a NetCDF HDF error. Skipping file '{filename}'."
@@ -170,24 +163,28 @@ class _Concat:
                 output.append(filename)
         return output
 
-    def _write_initial_data(self, variables: list | None, ignore: list | None) -> None:
-        for key in self.first_file.variables:
+    def _write_initial_data(self, keep: list | None, ignore: list | None) -> None:
+        len_concat_dim = self.first_file[self.concat_dimension].size
+        auto_scale = False
+
+        for key, var in self.first_file.variables.items():
             if (
-                variables is not None
-                and key not in variables
-                and key not in self.common_variables
+                # This filtering only affects variables having the concat_dimension
+                keep is not None
+                and key not in keep
                 and key != self.concat_dimension
+                and self.concat_dimension in var.dimensions
             ):
                 continue
             if ignore and key in ignore:
                 continue
 
-            auto_scale = False
-            self.first_file[key].set_auto_scale(auto_scale)
-            array = self.first_file[key][:]
-            dimensions = self.first_file[key].dimensions
-            fill_value = getattr(self.first_file[key], "_FillValue", None)
-            var = self.concatenated_file.createVariable(
+            var.set_auto_scale(auto_scale)
+            array, dimensions = self._expand_array(var, len_concat_dim)
+
+            fill_value = var.get_fill_value()
+
+            var_new = self.concatenated_file.createVariable(
                 key,
                 array.dtype,
                 dimensions,
@@ -196,37 +193,49 @@ class _Concat:
                 shuffle=False,
                 fill_value=fill_value,
             )
-            auto_scale = False
-            var.set_auto_scale(auto_scale)
-            var[:] = array
-            _copy_attributes(self.first_file[key], var)
-
-    def _append_data(self, filename: str | PathLike, allow_vary: list | None) -> None:
+            var_new.set_auto_scale(auto_scale)
+            var_new[:] = array
+            _copy_attributes(var, var_new)
+
+    def _expand_array(
+        self, var: netCDF4.Variable, n_data: int
+    ) -> tuple[ma.MaskedArray, tuple[str, ...]]:
+        dimensions = var.dimensions
+        arr = var[:]
+        if self.concat_dimension not in dimensions and var.name != self.interp_dim:
+            dimensions = (self.concat_dimension, *dimensions)
+            arr = np.repeat(arr[np.newaxis, ...], n_data, axis=0)
+
+        return arr, dimensions
+
+    def _append_data(self, filename: str | PathLike) -> None:
         with netCDF4.Dataset(filename) as file:
             auto_scale = False
             file.set_auto_scale(auto_scale)
             ind0 = len(self.concatenated_file.variables[self.concat_dimension])
             ind1 = ind0 + len(file.variables[self.concat_dimension])
+            n_points = ind1 - ind0
+
             for key in self.concatenated_file.variables:
-                if key not in file.variables:
-                    continue
-                array = file[key][:]
-                if key in self.common_variables:
-                    if allow_vary is not None and key in allow_vary:
-                        continue
-                    if not np.array_equal(self.first_file[key][:], array):
-                        msg = (
-                            f"Inconsistent values in variable '{key}' between "
-                            f"files '{self.first_filename}' and '{filename}'"
-                        )
-                        raise InconsistentDataError(msg)
+                if key not in file.variables or key == self.interp_dim:
                     continue
-                if array.ndim == 0:
-                    continue
-                if array.ndim == 1:
-                    self.concatenated_file.variables[key][ind0:ind1] = array
-                else:
-                    self.concatenated_file.variables[key][ind0:ind1, :] = array
+
+                array, dimensions = self._expand_array(file[key], n_points)
+
+                # Nearest neighbour interpolation in the interp_dim dimension
+                # if the dimensions are not the same between the files
+                if self.interp_dim in dimensions and (
+                    self.first_file[self.interp_dim].size != file[self.interp_dim].size
+                ):
+                    x = file.variables[self.interp_dim][:]
+                    x_target = self.first_file.variables[self.interp_dim][:]
+                    idx = np.abs(x[:, None] - x_target[None, :]).argmin(axis=0)
+                    array = array[:, idx]
+                    out_of_bounds = (x_target < x.min()) | (x_target > x.max())
+                    fill_value = self.first_file.variables[key].get_fill_value()
+                    array[:, out_of_bounds] = fill_value
+
+                self.concatenated_file.variables[key][ind0:ind1, ...] = array
 
     def _init_output_file(self, output_file: str) -> netCDF4.Dataset:
         data_model: Literal["NETCDF4", "NETCDF4_CLASSIC"] = (

cloudnetpy/datasource.py

@@ -182,53 +182,6 @@ class DataSource:
             return np.array(range_instrument + self.altitude)
         return None
 
-    def _variables_to_cloudnet_arrays(self, keys: tuple) -> None:
-        """Transforms netCDF4-variables into CloudnetArrays.
-
-        Args:
-            keys: netCDF4-variables to be converted. The results
-                are saved in *self.data* dictionary with *fields*
-                strings as keys.
-
-        Notes:
-            The attributes of the variables are not copied. Just the data.
-
-        """
-        for key in keys:
-            self.append_data(self.dataset.variables[key], key)
-
-    def _unknown_variable_to_cloudnet_array(
-        self,
-        possible_names: tuple,
-        key: str,
-        units: str | None = None,
-        *,
-        ignore_mask: bool = False,
-    ) -> None:
-        """Transforms single netCDF4 variable into CloudnetArray.
-
-        Args:
-            possible_names: Tuple of strings containing the possible
-                names of the variable in the input NetCDF file.
-            key: Key for self.data dictionary and name-attribute
-                for the saved CloudnetArray object.
-            units: Units attribute for the CloudnetArray object.
-            ignore_mask: If true, always writes an ordinary numpy array.
-
-        Raises:
-            RuntimeError: No variable found.
-
-        """
-        for name in possible_names:
-            if name in self.dataset.variables:
-                array: netCDF4.Variable | np.ndarray = self.dataset.variables[name]
-                if ignore_mask is True:
-                    array = np.array(array)
-                self.append_data(array, key, units=units)
-                return
-        msg = f"Missing variable {possible_names[0]} in the input file."
-        raise RuntimeError(msg)
-
     def __enter__(self):
         return self
 

cloudnetpy/instruments/bowtie.py

@@ -80,8 +80,8 @@ class Bowtie(NcRadar):
         self.data["relative_humidity"].data /= 100
 
     def fix_chirp_start_indices(self) -> None:
-        ind = self.data["chirp_start_indices"].data
-        self.data["chirp_start_indices"].data = np.array([int(i) for i in ind])
+        array = self.data["chirp_start_indices"].data
+        self.data["chirp_start_indices"].data = np.array(array, dtype=np.int32)
         self.data["chirp_start_indices"].data_type = "int32"
 
     def check_date(self, date: str):

cloudnetpy/instruments/copernicus.py

@@ -69,7 +69,6 @@ def copernicus2nc(
                 valid_filenames = utils.get_files_with_variables(
                     valid_filenames, ["time", "ZED_HC"]
                 )
-                valid_filenames = utils.get_files_with_common_range(valid_filenames)
                 variables = list(keymap.keys())
                 concat_lib.concatenate_files(
                     valid_filenames,

cloudnetpy/instruments/galileo.py

@@ -68,7 +68,6 @@ def galileo2nc(
                 valid_filenames = utils.get_files_with_variables(
                     valid_filenames, ["time", "ZED_HC"]
                 )
-                valid_filenames = utils.get_files_with_common_range(valid_filenames)
                 variables = list(keymap.keys())
                 concat_lib.concatenate_files(
                     valid_filenames,

cloudnetpy/instruments/mira.py

@@ -193,7 +193,6 @@ def _parse_input_files(input_files: str | list[str], temp_dir: str) -> tuple:
                 )
                 raise FileNotFoundError(msg)
 
-            valid_files = utils.get_files_with_common_range(valid_files)
             filetypes = list({f.split(".")[-1].lower() for f in valid_files})
 
             if len(filetypes) > 1:
@@ -208,15 +207,6 @@ def _parse_input_files(input_files: str | list[str], temp_dir: str) -> tuple:
                 input_filename,
                 variables=variables,
                 ignore=_get_ignored_variables(filetypes[0]),
-                # It's somewhat risky to use varying nfft values as the velocity
-                # resolution may differ, but this enables concatenation when switching
-                # between different nfft configurations. Spectral data is ignored
-                # anyway for now.
-                allow_difference=[
-                    "nave",
-                    "ovl",
-                    "nfft",
-                ],
             )
     else:
         input_filename = input_files

cloudnetpy/model_evaluation/plotting/plot_tools.py

@@ -97,7 +97,7 @@ def read_data_characters(nc_file: str, name: str, model: str) -> tuple:
     try:
         mask = y.mask
         if mask.any():
-            x, y, data = change2one_dim_axes(x, y, data)
+            x, y, data = change2one_dim_axes(ma.array(x), y, data)
     except AttributeError:
         return data, x, y
     return data, x, y

cloudnetpy/model_evaluation/tests/unit/test_advance_methods.py

@@ -65,7 +65,7 @@ def test_fit_z_sensitivity(obs_file, model_file) -> None:
     model = ModelManager(str(model_file), MODEL, OUTPUT_FILE, PRODUCT)
     adv_pro = AdvanceProductMethods(model, str(model_file), obs)
     h = np.array([[5000, 9000, 13000], [10000, 15000, 20000], [8000, 12000, 16000]])
-    compare = np.array([[0, 0.15, 0.5], [0.1, 1, 0], [0.15, 0, 1]])
+    compare = ma.masked_invalid([[np.nan, 0.15, 0.5], [0.1, 1, np.nan], [0.15, 0, 1]])
     x = adv_pro.fit_z_sensitivity(h)
     testing.assert_array_almost_equal(x, compare)
 

cloudnetpy/output.py

@@ -57,7 +57,11 @@ def _get_netcdf_dimensions(obj) -> dict:
     }
     # RPG cloud radar
     if "chirp_start_indices" in obj.data:
-        dimensions["chirp_sequence"] = len(obj.data["chirp_start_indices"][:])
+        if obj.data["chirp_start_indices"][:].ndim == 1:
+            dimensions["chirp_start_indices"] = len(obj.data["chirp_start_indices"][:])
+        else:
+            dimensions["chirp"] = obj.data["chirp_start_indices"][:].shape[1]
+
     # disdrometer
     if hasattr(obj, "n_diameter") and hasattr(obj, "n_velocity"):
         dimensions["diameter"] = obj.n_diameter

cloudnetpy/utils.py

@@ -3,7 +3,6 @@
 import base64
 import datetime
 import hashlib
-import logging
 import os
 import re
 import textwrap
@@ -11,7 +10,7 @@ import uuid
 import warnings
 from collections.abc import Iterator
 from datetime import timezone
-from typing import Literal, TypeVar
+from typing import Any, Literal, TypeVar
 
 import netCDF4
 import numpy as np
@@ -142,54 +141,42 @@ def binvec(x: np.ndarray | list) -> np.ndarray:
 
 def rebin_2d(
     x_in: np.ndarray,
-    array: ma.MaskedArray,
+    array: np.ndarray,
     x_new: np.ndarray,
-    statistic: Literal["mean", "std"] = "mean",
+    statistic: Literal["mean", "std", "max"] = "mean",
     n_min: int = 1,
     *,
-    mask_zeros: bool = True,
-) -> tuple[ma.MaskedArray, list]:
-    """Rebins 2-D data in one dimension.
+    keepdim: bool = False,
+    mask_zeros: bool = False,
+) -> tuple[ma.MaskedArray, np.ndarray]:
+    edges = binvec(x_new)
+    binn = np.digitize(x_in, edges) - 1
+    n_bins = len(x_new)
+    counts = np.bincount(binn[binn >= 0], minlength=n_bins)
 
-    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,).
-        statistic: Statistic to be calculated. Possible statistics are 'mean', 'std'.
-            Default is 'mean'.
-        n_min: Minimum number of points to have good statistics in a bin. Default is 1.
-        mask_zeros: Whether to mask 0 values in the returned array. Default is True.
+    stat_fn: Any = {
+        "mean": ma.mean,
+        "std": ma.std,
+        "max": ma.max,
+    }[statistic]
 
-    Returns:
-        tuple: Rebinned data with shape (N, m) and indices of bins without enough data.
-    """
-    edges = binvec(x_new)
-    result = np.zeros((len(x_new), array.shape[1]))
-    array_screened = ma.masked_invalid(array, copy=True)  # data may contain nan-values
-    for ind, values in enumerate(array_screened.T):
-        mask = ~values.mask
-        if ma.any(values[mask]):
-            result[:, ind], _, _ = stats.binned_statistic(
-                x_in[mask],
-                values[mask],
-                statistic=statistic,
-                bins=edges,
-            )
-    result[~np.isfinite(result)] = 0
-    if mask_zeros is True:
-        masked_result = ma.masked_equal(result, 0)
-    else:
-        masked_result = ma.array(result)
+    shape = array.shape if keepdim else (n_bins, array.shape[1])
+    result: ma.MaskedArray = ma.masked_array(np.ones(shape, dtype="float32"), mask=True)
+
+    for bin_ind in range(n_bins):
+        if counts[bin_ind] < n_min:
+            continue
+        mask = binn == bin_ind
+        block = array[mask, :]
+        x_ind = mask if keepdim else bin_ind
+        result[x_ind, :] = stat_fn(block, axis=0)
+
+    empty_bins = np.where(counts < n_min)[0]
 
-    # Fill bins with not enough profiles
-    x_hist, _ = np.histogram(x_in, bins=edges)
-    empty_mask = x_hist < n_min
-    masked_result[empty_mask, :] = ma.masked
-    empty_indices = list(np.nonzero(empty_mask)[0])
-    if len(empty_indices) > 0:
-        logging.debug("No data in %s bins", len(empty_indices))
+    if mask_zeros:
+        result[result == 0] = ma.masked
 
-    return masked_result, empty_indices
+    return result, empty_bins
 
 
 def rebin_1d(
@@ -197,8 +184,6 @@ def rebin_1d(
     array: np.ndarray | ma.MaskedArray,
     x_new: np.ndarray,
     statistic: str = "mean",
-    *,
-    mask_zeros: bool = True,
 ) -> ma.MaskedArray:
     """Rebins 1D array.
 
@@ -208,14 +193,13 @@ def rebin_1d(
         x_new: 1-D target vector (center points) with shape (N,).
         statistic: Statistic to be calculated. Possible statistics are 'mean', 'std'.
             Default is 'mean'.
-        mask_zeros: Whether to mask 0 values in the returned array. Default is True.
 
     Returns:
         Re-binned data with shape (N,).
 
     """
     edges = binvec(x_new)
-    result = np.zeros(len(x_new))
+    result = ma.zeros(len(x_new))
     array_screened = ma.masked_invalid(array, copy=True)  # data may contain nan-values
     mask = ~array_screened.mask
     if ma.any(array_screened[mask]):
@@ -225,10 +209,7 @@ def rebin_1d(
             statistic=statistic,
             bins=edges,
         )
-    result[~np.isfinite(result)] = 0
-    if mask_zeros:
-        return ma.masked_equal(result, 0)
-    return ma.array(result)
+    return ma.masked_invalid(result, copy=True)
 
 
 def filter_isolated_pixels(array: np.ndarray) -> np.ndarray:
@@ -960,21 +941,6 @@ def get_file_type(filename: str) -> str:
     raise ValueError(msg)
 
 
-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 filenames:
-        with netCDF4.Dataset(file) as nc:
-            n_range.append(len(nc.variables["range"]))
-    most_common = np.bincount(n_range).argmax()
-    n_removed = len(filenames) - n_range.count(int(most_common))
-    if n_removed > 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 get_files_with_variables(filenames: list, variables: list[str]) -> list:
     """Returns files where all variables exist."""
     valid_files = []

cloudnetpy/version.py

@@ -1,4 +1,4 @@
 MAJOR = 1
-MINOR = 77
-PATCH = 2
+MINOR = 78
+PATCH = 1
 __version__ = f"{MAJOR}.{MINOR}.{PATCH}"

{cloudnetpy-1.77.2.dist-info → cloudnetpy-1.78.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudnetpy
-Version: 1.77.2
+Version: 1.78.1
 Summary: Python package for Cloudnet processing
 Author: Simo Tukiainen
 License: MIT License

{cloudnetpy-1.77.2.dist-info → cloudnetpy-1.78.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
 cloudnetpy/__init__.py,sha256=X_FqY-4yg5GUj5Edo14SToLEos6JIsC3fN-v1FUgQoA,43
 cloudnetpy/cli.py,sha256=lHkeAErmAijI-Ugpd4DHRHfbZP4SXOake0LIY5Ovv_Q,20782
-cloudnetpy/cloudnetarray.py,sha256=XFyXZwR4QWPyo7WLmvsu7DEELZQp1vi5FZ8F7tX_tM0,7307
-cloudnetpy/concat_lib.py,sha256=jcLppqAmVHVkykcXBcpwUr8MS_k8v2Xl2xBLmVRE_DI,12624
+cloudnetpy/cloudnetarray.py,sha256=uOYgpQ8hHh5fuHyip1HjnhsEda9_7dg7orYnbCRkTtI,4796
+cloudnetpy/concat_lib.py,sha256=XQ5Sk8kfXqI0Q5HoomKWWhdZ1-m2thYDKGL7SKapITE,12851
 cloudnetpy/constants.py,sha256=YnoSzZm35NDooJfhlulSJBc7g0eSchT3yGytRaTaJEI,845
-cloudnetpy/datasource.py,sha256=FcWS77jz56gIzwnbafDLdj-HjAyu0P_VtY7gkeVZThU,7952
+cloudnetpy/datasource.py,sha256=Vx_I8S14nFAWKI0VbsW_-sllbVCRjTYxB7XH9b9PedQ,6268
 cloudnetpy/exceptions.py,sha256=hYbUtBwjCIfxnPe_5mELDEw87AWITBrwuo7WYIEKmJ8,1579
 cloudnetpy/metadata.py,sha256=lO7BCbVAzFoH3Nq-VuezYX0f7MnbG1Zp11g5GSiuQwM,6189
-cloudnetpy/output.py,sha256=l0LoOhcGCBrg2EJ4NT1xZ7-UKWdV7X7yQ0fJmhkwJVc,15829
+cloudnetpy/output.py,sha256=gupxt4f_-eUrFsWMto8tnknoV-p9QauC9L6CJAqBILU,15988
 cloudnetpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cloudnetpy/utils.py,sha256=FFV4MRoiJfcbbknMD5DM-VesY-7yCb8jzeeadyyijLg,33532
-cloudnetpy/version.py,sha256=MBEzrrjK2C6qfoMHCRMYDIMl98CZIE1aPKuEZsjCPeo,72
+cloudnetpy/utils.py,sha256=HdcSNIgdxoZlP_jHl66ItheHLw_cDYZb7u6mZ5dfMNE,31952
+cloudnetpy/version.py,sha256=3xCJ6Zv7LkLahqubKZWS5YDwui01I7yk-Z-3oUGO9Us,72
 cloudnetpy/categorize/__init__.py,sha256=s-SJaysvVpVVo5kidiruWQO6p3gv2TXwY1wEHYO5D6I,44
 cloudnetpy/categorize/atmos_utils.py,sha256=RcmbKxm2COkE7WEya0mK3yX5rzUbrewRVh3ekm01RtM,10598
 cloudnetpy/categorize/attenuation.py,sha256=Y_-fzmQTltWTqIZTulJhovC7a6ifpMcaAazDJcnMIOc,990
@@ -20,13 +20,13 @@ cloudnetpy/categorize/disdrometer.py,sha256=sRSt2B932lrrkvycKoSaKEIaDVfq9Z7uU-4i
 cloudnetpy/categorize/droplet.py,sha256=t49KEsH5ZM68JQ4NvAf9kGgQ-evic1T4de2-jgJ2f4M,8683
 cloudnetpy/categorize/falling.py,sha256=lok0HMi1ewf9pS70mq62nRKL6wJzMyWbYmv1cdwrwnA,4404
 cloudnetpy/categorize/freezing.py,sha256=eSFD37R7vBrg7mgfSanrwhBjnFyWNBpjw2AtvRmSh48,3753
-cloudnetpy/categorize/insects.py,sha256=9J5agmktit8Or66GGNue-bThiaG9rB2SuPNZBXI7FCE,5243
+cloudnetpy/categorize/insects.py,sha256=MrxlWK-5JaMZxCBWFKR_6Kj5TAVXm-s9SVxsvcyNYJo,5253
 cloudnetpy/categorize/itu.py,sha256=ffXK27guyRS4d66VWQ2h4UEGjUIhGjPKbFmj7kh698c,10304
 cloudnetpy/categorize/lidar.py,sha256=YQrM_LOz8NQrrD9l9HyujV1GSGwkQ8LMqXN13bEJRW4,2605
 cloudnetpy/categorize/melting.py,sha256=ZnLeL_qWmiCdjXVOm9iBYHdo29Brqxu_DEErZPqUloQ,6217
 cloudnetpy/categorize/model.py,sha256=QFRCY0TvM2fzGRyP8BNkqbvu13XcQjt7TsN5fhjI_Uc,6654
 cloudnetpy/categorize/mwr.py,sha256=F7cquERWL6mBkgboqeaCIPf9gOlKI-NWUQIBdQXGT_I,1635
-cloudnetpy/categorize/radar.py,sha256=PmriTnrHbgZrau1RTNKpPI_-h5Uu0kGIMrMOaoMuROY,14821
+cloudnetpy/categorize/radar.py,sha256=z2bFF_wAKbzzXB3Pq1z33Y1RMv6NL-8CdZesU89qzpw,15502
 cloudnetpy/categorize/attenuations/__init__.py,sha256=CWFHVWeTIe2hrZtgkJaX2HGftbuffsFc39Mzv5B0Lw0,1037
 cloudnetpy/categorize/attenuations/gas_attenuation.py,sha256=emr-RCxQT0i2N8k6eBNhRsmsCBPHJzQsWJfjC4fVSTo,975
 cloudnetpy/categorize/attenuations/liquid_attenuation.py,sha256=0p0G79BPkw1itCXHMwbvkNHtJGBocJzow3gNHAirChI,3036
@@ -34,18 +34,18 @@ cloudnetpy/categorize/attenuations/melting_attenuation.py,sha256=9c9xoZHtGUbjFYJ
 cloudnetpy/categorize/attenuations/rain_attenuation.py,sha256=qazJzRyXf9vbjJhh4yiFmABI4L57j5W_6YZ-6qjRiBI,2839
 cloudnetpy/instruments/__init__.py,sha256=PEgrrQNoiOuN_ctYilmt4LV2QCLg1likPjJdWtuGlLs,528
 cloudnetpy/instruments/basta.py,sha256=Lb_EhQTI93S5Bd9osDbCE_tC8gZreRsHz7D2_dFOjmE,3793
-cloudnetpy/instruments/bowtie.py,sha256=jrEkOsZ4ScwmTN35rAwIbVHkHxQatFCHiuzBjVA4pJ0,3279
+cloudnetpy/instruments/bowtie.py,sha256=GlWCxemeXrIvWnnQRvZa1ttl4J0NmLUdc7xngIH5WBI,3281
 cloudnetpy/instruments/ceilo.py,sha256=qM3AkQKHUblhRCD42HsB6lr82giBH-0g_VzoWHZDgeA,9535
 cloudnetpy/instruments/ceilometer.py,sha256=ati9-fUQ54K9tvynIPB-nlBYwtvBVaQtUCjVCLNB67w,12059
 cloudnetpy/instruments/cl61d.py,sha256=g6DNBFju3wYhLFl32DKmC8pUup7y-EupXoUU0fuoGGA,1990
 cloudnetpy/instruments/cloudnet_instrument.py,sha256=SGPsRYYoGPoRoDY7hHJcKUVX0A23X0Telc00Fu01PnY,4495
-cloudnetpy/instruments/copernicus.py,sha256=99idcn6-iKOSvSslNjwFRng3gwlTLFjKPiT1tnVytpQ,6613
+cloudnetpy/instruments/copernicus.py,sha256=hCphEKyFCc3f1uLRdjL2435kuh64M5q-V1bI68bzGbA,6528
 cloudnetpy/instruments/fd12p.py,sha256=aGYpkczdSl7FSmK1bByMnpUBD5GAl7RTKkopt0cpWas,6822
-cloudnetpy/instruments/galileo.py,sha256=BjWE15_S3tTCOmAM5k--oicI3wghKaO0hv9EUBxtbl8,4830
+cloudnetpy/instruments/galileo.py,sha256=vcY7mYcGD8YtMw8ioy9CNGu5yarQlwE-vfWIRSbTQG0,4745
 cloudnetpy/instruments/hatpro.py,sha256=G1fHsY9LTos4vHP5kFubjE5Wg2uTVFZpYDSD8VAo-zw,9590
 cloudnetpy/instruments/instruments.py,sha256=z8Osjww3iQRxKvzXdISl-5vV6gShtji8Db5k-ZzDQ-0,4843
 cloudnetpy/instruments/lufft.py,sha256=nIoEKuuFGKq2dLqkX7zW-HpAifefG472tZhKfXE1yoA,4212
-cloudnetpy/instruments/mira.py,sha256=IH88dnV5fdAQ-A04S23ROgNmT4GBAtzXQxCr_9fWj-Q,11634
+cloudnetpy/instruments/mira.py,sha256=mH53Wpq3JnmHqDa2Bo0t6REEf8OQ4MjkHYm8AEM2_S4,11140
 cloudnetpy/instruments/mrr.py,sha256=eeAzCp3CiHGauywjwvMUAFwZ4vBOZMcd3IlF8KsrLQo,5711
 cloudnetpy/instruments/nc_lidar.py,sha256=5gQG9PApnNPrHmS9_zanl8HEYIQuGRpbnzC3wfTcOyQ,1705
 cloudnetpy/instruments/nc_radar.py,sha256=HlaZeH5939R86ukF8K-P4Kfzb5-CpLB15LU2u94C5eI,7330
@@ -68,7 +68,7 @@ cloudnetpy/model_evaluation/model_metadata.py,sha256=CxpY6RPm7GOTBBmPhcNVVpm9ate
 cloudnetpy/model_evaluation/utils.py,sha256=Z9VqYVdtY9yTr2JeVfBn4nccIVWCN5Fd-BCyB_qYI-A,154
 cloudnetpy/model_evaluation/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloudnetpy/model_evaluation/plotting/plot_meta.py,sha256=K18Ugohh24uVAIxjZgJsmK80YwsMstm6B7ptVafONAw,3557
-cloudnetpy/model_evaluation/plotting/plot_tools.py,sha256=gV042W_AHidwPsRe2L57xdWbt3W-utcHMt_9FmfYK3M,5033
+cloudnetpy/model_evaluation/plotting/plot_tools.py,sha256=umI06tPIEs48cQ8GY8s3vGHwPcN--tUir4s1yxNQf64,5043
 cloudnetpy/model_evaluation/plotting/plotting.py,sha256=mGgSnQoRTh04v5RSJHsYPaqUEIR82eZqAuiszrh9rjY,31235
 cloudnetpy/model_evaluation/products/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloudnetpy/model_evaluation/products/advance_methods.py,sha256=rng3ZLR1Arv1AGUzq0Ehu-65628PC5LZVKpHSUpCIW8,8526
@@ -93,7 +93,7 @@ cloudnetpy/model_evaluation/tests/e2e/process_lwc/main.py,sha256=IFcPj-Vce9Yn0Cf
 cloudnetpy/model_evaluation/tests/e2e/process_lwc/tests.py,sha256=ANBA0LVao3Xrm-prRnwUmxM6BdQzqM7GZNKB3uz5BXQ,1725
 cloudnetpy/model_evaluation/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloudnetpy/model_evaluation/tests/unit/conftest.py,sha256=WL_FgrDeoUYGp4PKjb37HLu79D9uu33PGQL40_ctqS0,7446
-cloudnetpy/model_evaluation/tests/unit/test_advance_methods.py,sha256=IkoAVtsWVFrPpFqQOLAPHKb9qgV-KjGGVEtWMudeiSo,10079
+cloudnetpy/model_evaluation/tests/unit/test_advance_methods.py,sha256=UEF94sBN8pPOyoz5ARag3mc5A8KFjyY_-IJFqdKBGug,10098
 cloudnetpy/model_evaluation/tests/unit/test_grid_methods.py,sha256=AEUXN5HBhKliPsSNGDCUtWOtIx6Y8iqkywb_-RfXYU0,26277
 cloudnetpy/model_evaluation/tests/unit/test_model_products.py,sha256=FRbYLshSHH2E527uJPwvUIyZKTsPFSZrwDsPsNrFSSU,3475
 cloudnetpy/model_evaluation/tests/unit/test_observation_products.py,sha256=DN3yVqq8vFYca_9POjcrJ8XViMrJks_jM-aQznfN8QQ,4936
@@ -117,10 +117,10 @@ cloudnetpy/products/lwc.py,sha256=sl6Al2tuH3KkCBrPbWTmuz3jlD5UQJ4D6qBsn1tt2CQ,18
 cloudnetpy/products/mie_lu_tables.nc,sha256=It4fYpqJXlqOgL8jeZ-PxGzP08PMrELIDVe55y9ob58,16637951
 cloudnetpy/products/mwr_tools.py,sha256=8HPZpQMTojKZP1JS1S83IE0sxmbDE9bxlaWoqmGnUZE,6199
 cloudnetpy/products/product_tools.py,sha256=uu4l6reuGbPcW3TgttbaSrqIKbyYGhBVTdnC7opKvmg,11101
-cloudnetpy-1.77.2.dist-info/licenses/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
+cloudnetpy-1.78.1.dist-info/licenses/LICENSE,sha256=wcZF72bdaoG9XugpyE95Juo7lBQOwLuTKBOhhtANZMM,1094
 docs/source/conf.py,sha256=IKiFWw6xhUd8NrCg0q7l596Ck1d61XWeVjIFHVSG9Og,1490
-cloudnetpy-1.77.2.dist-info/METADATA,sha256=soDh6zzIkRMSYIeYp6NiOTksTWZX0zttG8MnWJuFjNs,5796
-cloudnetpy-1.77.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-cloudnetpy-1.77.2.dist-info/entry_points.txt,sha256=HhY7LwCFk4qFgDlXx_Fy983ZTd831WlhtdPIzV-Y3dY,51
-cloudnetpy-1.77.2.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
-cloudnetpy-1.77.2.dist-info/RECORD,,
+cloudnetpy-1.78.1.dist-info/METADATA,sha256=AznJgGBfGvD7cbWAieBBM5xVu3Wn9GQebLBXaAVFJUE,5796
+cloudnetpy-1.78.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cloudnetpy-1.78.1.dist-info/entry_points.txt,sha256=HhY7LwCFk4qFgDlXx_Fy983ZTd831WlhtdPIzV-Y3dY,51
+cloudnetpy-1.78.1.dist-info/top_level.txt,sha256=ibSPWRr6ojS1i11rtBFz2_gkIe68mggj7aeswYfaOo0,16
+cloudnetpy-1.78.1.dist-info/RECORD,,

{cloudnetpy-1.77.2.dist-info → cloudnetpy-1.78.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any