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

cloudnetpy/products/classification.py

@@ -1,6 +1,10 @@
 """Module for creating classification file."""
 
+from os import PathLike
+from uuid import UUID
+
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import output, utils
@@ -11,10 +15,10 @@ from cloudnetpy.products.product_tools import CategorizeBits
 
 
 def generate_classification(
-    categorize_file: str,
-    output_file: str,
-    uuid: str | None = None,
-) -> str:
+    categorize_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+) -> UUID:
     """Generates Cloudnet classification product.
 
     This function reads the initial classification masks from a
@@ -35,6 +39,7 @@ def generate_classification(
         >>> generate_classification('categorize.nc', 'classification.nc')
 
     """
+    uuid = utils.get_uuid(uuid)
     with DataSource(categorize_file) as product_container:
         categorize_bits = CategorizeBits(categorize_file)
         classification = _get_target_classification(categorize_bits)
@@ -58,12 +63,13 @@ def generate_classification(
         file_type = "classification"
         if "liquid_prob" in product_container.dataset.variables:
             file_type += "-voodoo"
-        return output.save_product_file(
+        output.save_product_file(
             file_type,
             product_container,
             output_file,
             uuid,
         )
+        return uuid
 
 
 def _get_target_classification(
@@ -86,7 +92,7 @@ def _get_target_classification(
     return classification
 
 
-def _get_detection_status(categorize_bits: CategorizeBits) -> np.ndarray:
+def _get_detection_status(categorize_bits: CategorizeBits) -> npt.NDArray:
     bits = categorize_bits.quality_bits
 
     is_attenuated = (
@@ -113,9 +119,9 @@ def _get_detection_status(categorize_bits: CategorizeBits) -> np.ndarray:
 
 
 def _get_cloud_base_and_top_heights(
-    classification: np.ndarray,
+    classification: npt.NDArray,
     product_container: DataSource,
-) -> tuple[np.ndarray, np.ndarray]:
+) -> tuple[npt.NDArray, npt.NDArray]:
     height = product_container.getvar("height")
     cloud_mask = _find_cloud_mask(classification)
     if not cloud_mask.any():
@@ -128,7 +134,7 @@ def _get_cloud_base_and_top_heights(
     return lowest_bases, highest_tops
 
 
-def _find_cloud_mask(classification: np.ndarray) -> np.ndarray:
+def _find_cloud_mask(classification: npt.NDArray) -> npt.NDArray:
     cloud_mask = np.zeros(classification.shape, dtype=int)
     for value in [1, 3, 4, 5]:
         cloud_mask[classification == value] = 1

cloudnetpy/products/der.py

@@ -2,9 +2,12 @@
 using the Frisch et al. 2002 method.
 """
 
+from os import PathLike
 from typing import NamedTuple
+from uuid import UUID
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import output, utils
@@ -29,11 +32,11 @@ class Parameters(NamedTuple):
 
 
 def generate_der(
-    categorize_file: str,
-    output_file: str,
-    uuid: str | None = None,
+    categorize_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
     parameters: Parameters | None = None,
-) -> str:
+) -> UUID:
     """Generates Cloudnet effective radius of liquid water droplets
         product according to Frisch et al. 2002.
 
@@ -69,16 +72,16 @@ def generate_der(
         https://doi.org/10.1175/1520-0426(2002)019%3C0835:TROSCD%3E2.0.CO;2
 
     """
-    der_source = DerSource(categorize_file, parameters)
-    droplet_classification = DropletClassification(categorize_file)
-    der_source.append_der()
-    der_source.append_retrieval_status(droplet_classification)
-    date = der_source.get_date()
-    attributes = output.add_time_attribute(REFF_ATTRIBUTES, date)
-    attributes = _add_der_error_comment(attributes, der_source)
-    output.update_attributes(der_source.data, attributes)
-    uuid = output.save_product_file("der", der_source, output_file, uuid)
-    der_source.close()
+    uuid = utils.get_uuid(uuid)
+    with DerSource(categorize_file, parameters) as der_source:
+        droplet_classification = DropletClassification(categorize_file)
+        der_source.append_der()
+        der_source.append_retrieval_status(droplet_classification)
+        date = der_source.get_date()
+        attributes = output.add_time_attribute(REFF_ATTRIBUTES, date)
+        attributes = _add_der_error_comment(attributes, der_source)
+        output.update_attributes(der_source.data, attributes)
+        output.save_product_file("der", der_source, output_file, uuid)
     return uuid
 
 
@@ -87,19 +90,19 @@ class DropletClassification(ProductClassification):
     Child of ProductClassification().
     """
 
-    def __init__(self, categorize_file: str):
+    def __init__(self, categorize_file: str | PathLike) -> None:
         super().__init__(categorize_file)
         self.is_mixed = self._find_mixed()
         self.is_droplet = self._find_droplet()
         self.is_ice = self._find_ice()
 
-    def _find_droplet(self) -> np.ndarray:
+    def _find_droplet(self) -> npt.NDArray:
         return self.category_bits.droplet
 
-    def _find_mixed(self) -> np.ndarray:
+    def _find_mixed(self) -> npt.NDArray:
         return self.category_bits.falling & self.category_bits.droplet
 
-    def _find_ice(self) -> np.ndarray:
+    def _find_ice(self) -> npt.NDArray:
         return (
             self.category_bits.falling
             & self.category_bits.freezing
@@ -112,7 +115,9 @@ class DropletClassification(ProductClassification):
 class DerSource(DataSource):
     """Data container for effective radius calculations."""
 
-    def __init__(self, categorize_file: str, parameters: Parameters | None = None):
+    def __init__(
+        self, categorize_file: str | PathLike, parameters: Parameters | None = None
+    ) -> None:
         super().__init__(categorize_file)
         if "lwp" not in self.dataset.variables:
             msg = "Liquid water path missing from the categorize file."

cloudnetpy/products/drizzle.py

@@ -1,6 +1,10 @@
 """Module for creating Cloudnet drizzle product."""
 
+from os import PathLike
+from uuid import UUID
+
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy.special import gamma
 
@@ -16,10 +20,10 @@ from cloudnetpy.products.drizzle_tools import (
 
 
 def generate_drizzle(
-    categorize_file: str,
-    output_file: str,
-    uuid: str | None = None,
-) -> str:
+    categorize_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+) -> UUID:
     """Generates Cloudnet drizzle product.
 
     This function calculates different drizzle properties from
@@ -43,6 +47,7 @@ def generate_drizzle(
         J. Appl. Meteor., 44, 14–27, https://doi.org/10.1175/JAM-2181.1
 
     """
+    uuid = utils.get_uuid(uuid)
     with DrizzleSource(categorize_file) as drizzle_source:
         drizzle_class = DrizzleClassification(categorize_file)
         spectral_width = SpectralWidth(categorize_file)
@@ -61,7 +66,8 @@ def generate_drizzle(
         date = drizzle_source.get_date()
         attributes = output.add_time_attribute(DRIZZLE_ATTRIBUTES, date)
         output.update_attributes(drizzle_source.data, attributes)
-        return output.save_product_file("drizzle", drizzle_source, output_file, uuid)
+        output.save_product_file("drizzle", drizzle_source, output_file, uuid)
+        return uuid
 
 
 class DrizzleProducts:
@@ -77,7 +83,9 @@ class DrizzleProducts:
 
     """
 
-    def __init__(self, drizzle_source: DrizzleSource, drizzle_solver: DrizzleSolver):
+    def __init__(
+        self, drizzle_source: DrizzleSource, drizzle_solver: DrizzleSolver
+    ) -> None:
         self._data = drizzle_source
         self._params = drizzle_solver.params
         self._ind_drizzle, self._ind_lut = self._find_indices()
@@ -106,13 +114,13 @@ class DrizzleProducts:
             "v_air": v_air,
         }
 
-    def _calc_density(self) -> np.ndarray:
+    def _calc_density(self) -> npt.NDArray:
         """Calculates drizzle number density (m-3)."""
         a = self._data.z * 3.67**6
         b = self._params["Do"] ** 6
         return np.divide(a, b, out=np.zeros_like(a), where=b != 0)
 
-    def _calc_lwc(self) -> np.ndarray:
+    def _calc_lwc(self) -> npt.NDArray:
         """Calculates drizzle liquid water content (kg m-3)."""
         rho_water = 1000
         dia, mu, s = (self._params.get(key) for key in ("Do", "mu", "S"))
@@ -122,7 +130,7 @@ class DrizzleProducts:
         gamma_ratio = gamma(4 + mu) / gamma(3 + mu) / (3.67 + mu)
         return rho_water / 3 * self._data.beta * s * dia * gamma_ratio
 
-    def _calc_lwf(self, lwc_in) -> np.ndarray:
+    def _calc_lwf(self, lwc_in: npt.NDArray) -> npt.NDArray:
         """Calculates drizzle liquid water flux."""
         flux = ma.copy(lwc_in)
         flux[self._ind_drizzle] *= (
@@ -131,13 +139,13 @@ class DrizzleProducts:
         )
         return flux
 
-    def _calc_fall_velocity(self) -> np.ndarray:
+    def _calc_fall_velocity(self) -> npt.NDArray:
         """Calculates drizzle droplet fall velocity (m s-1)."""
         velocity = np.zeros_like(self._params["Do"])
         velocity[self._ind_drizzle] = -self._data.mie["v"][self._ind_lut]
         return velocity
 
-    def _calc_v_air(self, droplet_velocity) -> np.ndarray:
+    def _calc_v_air(self, droplet_velocity: npt.NDArray) -> npt.NDArray:
         """Calculates vertical air velocity."""
         velocity = -np.copy(droplet_velocity)
         velocity[self._ind_drizzle] += self._data.v[self._ind_drizzle]
@@ -156,9 +164,9 @@ class RetrievalStatus:
             status information.
     """
 
-    def __init__(self, drizzle_class: DrizzleClassification):
+    def __init__(self, drizzle_class: DrizzleClassification) -> None:
         self.drizzle_class = drizzle_class
-        self.retrieval_status: np.ndarray = np.array([])
+        self.retrieval_status: npt.NDArray = np.array([])
         self._get_retrieval_status()
 
     def _get_retrieval_status(self) -> None:

cloudnetpy/products/drizzle_error.py

@@ -1,4 +1,5 @@
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import utils
@@ -33,7 +34,7 @@ def get_drizzle_error(
     return _calc_errors(drizzle_indices, error_input, bias_input)
 
 
-def _get_drizzle_indices(diameter: np.ndarray) -> dict:
+def _get_drizzle_indices(diameter: npt.NDArray) -> dict:
     return {
         "drizzle": diameter > 0,
         "small": np.logical_and(diameter <= 1e-4, diameter > 1e-5),
@@ -154,12 +155,12 @@ def _calc_error(
 
 
 def _stack_errors(
-    error_in: np.ndarray,
+    error_in: npt.NDArray,
     drizzle_indices: dict,
-    error_small=None,
-    error_tiny=None,
+    error_small: npt.NDArray | None = None,
+    error_tiny: npt.NDArray | None = None,
 ) -> ma.MaskedArray:
-    def _add_error_component(source: np.ndarray, ind: tuple) -> None:
+    def _add_error_component(source: npt.NDArray, ind: tuple) -> None:
         error[ind] = source[ind]
 
     error = ma.zeros(error_in.shape)
@@ -174,14 +175,14 @@ def _stack_errors(
 COR = 10 / np.log(10)
 
 
-def db2lin(x_in: np.ndarray) -> ma.MaskedArray:
+def db2lin(x_in: npt.NDArray) -> ma.MaskedArray:
     x = ma.copy(x_in)
     threshold = 100
     x[x > threshold] = threshold
     return ma.exp(x / COR) - 1
 
 
-def lin2db(x_in) -> ma.MaskedArray:
+def lin2db(x_in: npt.NDArray) -> ma.MaskedArray:
     x = ma.copy(x_in)
     threshold = -0.9
     x[x < threshold] = threshold

cloudnetpy/products/drizzle_tools.py

@@ -1,9 +1,11 @@
 import logging
 import os
 from bisect import bisect_left
+from os import PathLike
 
 import netCDF4
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from scipy.special import gamma
 
@@ -27,7 +29,7 @@ class DrizzleSource(DataSource):
 
     """
 
-    def __init__(self, categorize_file: str):
+    def __init__(self, categorize_file: str | PathLike) -> None:
         super().__init__(categorize_file)
         self.mie = self._read_mie_lut()
         self.height_vector = self.getvar("height")
@@ -35,7 +37,7 @@ class DrizzleSource(DataSource):
         self.beta = self.getvar("beta")
         self.v = self.getvar("v")
 
-    def _convert_z_units(self) -> np.ndarray:
+    def _convert_z_units(self) -> npt.NDArray:
         """Converts reflectivity factor to SI units."""
         z = self.getvar("Z") - 180
         z[z > 0.0] = 0.0
@@ -96,7 +98,7 @@ class DrizzleClassification(ProductClassification):
 
     """
 
-    def __init__(self, categorize_file: str):
+    def __init__(self, categorize_file: str | PathLike) -> None:
         super().__init__(categorize_file)
         self.is_v_sigma = self._find_v_sigma(categorize_file)
         self.warm_liquid = self._find_warm_liquid()
@@ -105,14 +107,14 @@ class DrizzleClassification(ProductClassification):
         self.cold_rain = self._find_cold_rain()
 
     @staticmethod
-    def _find_v_sigma(cat_file: str) -> np.ndarray:
+    def _find_v_sigma(cat_file: str | PathLike) -> npt.NDArray:
         v_sigma = product_tools.read_nc_field(cat_file, "v_sigma")
         return np.isfinite(v_sigma)
 
-    def _find_warm_liquid(self) -> np.ndarray:
+    def _find_warm_liquid(self) -> npt.NDArray:
         return self.category_bits.droplet & ~self.category_bits.freezing
 
-    def _find_drizzle(self) -> np.ndarray:
+    def _find_drizzle(self) -> npt.NDArray:
         return (
             ~utils.transpose(self.is_rain)
             & self.category_bits.falling
@@ -129,7 +131,7 @@ class DrizzleClassification(ProductClassification):
             & self.is_v_sigma
         )
 
-    def _find_would_be_drizzle(self) -> np.ndarray:
+    def _find_would_be_drizzle(self) -> npt.NDArray:
         return (
             ~utils.transpose(self.is_rain)
             & self.warm_liquid
@@ -141,7 +143,7 @@ class DrizzleClassification(ProductClassification):
             & ~self.quality_bits.molecular
         )
 
-    def _find_cold_rain(self) -> np.ndarray:
+    def _find_cold_rain(self) -> npt.NDArray:
         return np.any(self.category_bits.melting, axis=1)
 
 
@@ -161,11 +163,11 @@ class SpectralWidth:
 
     """
 
-    def __init__(self, categorize_file: str):
+    def __init__(self, categorize_file: str | PathLike) -> None:
         self.cat_file = categorize_file
         self.width_ht = self._calculate_spectral_width()
 
-    def _calculate_spectral_width(self) -> np.ndarray:
+    def _calculate_spectral_width(self) -> npt.NDArray:
         v_sigma = product_tools.read_nc_field(self.cat_file, "v_sigma")
         try:
             width = product_tools.read_nc_field(self.cat_file, "width")
@@ -175,19 +177,19 @@ class SpectralWidth:
         sigma_factor = self._calc_v_sigma_factor()
         return width - sigma_factor * v_sigma
 
-    def _calc_v_sigma_factor(self) -> np.ndarray:
+    def _calc_v_sigma_factor(self) -> npt.NDArray:
         beam_divergence = self._calc_beam_divergence()
         wind = self._calc_horizontal_wind()
         actual_wind = (wind + beam_divergence) ** (2 / 3)
         scaled_wind = (30 * wind + beam_divergence) ** (2 / 3)
         return actual_wind / (scaled_wind - actual_wind)
 
-    def _calc_beam_divergence(self) -> np.ndarray:
+    def _calc_beam_divergence(self) -> npt.NDArray:
         beam_width = 0.5
         height = product_tools.read_nc_field(self.cat_file, "height")
         return height * np.deg2rad(beam_width)
 
-    def _calc_horizontal_wind(self) -> np.ndarray:
+    def _calc_horizontal_wind(self) -> npt.NDArray:
         """Calculates magnitude of horizontal wind.
 
         Returns:
@@ -219,7 +221,7 @@ class DrizzleSolver:
         drizzle_source: DrizzleSource,
         drizzle_class: DrizzleClassification,
         spectral_width: SpectralWidth,
-    ):
+    ) -> None:
         self._data = drizzle_source
         self._drizzle_class = drizzle_class
         self._width_ht = spectral_width.width_ht
@@ -228,7 +230,7 @@ class DrizzleSolver:
         self._beta_z_ratio = self._calc_beta_z_ratio()
         self._solve_drizzle(self._dia_init)
 
-    def _init_variables(self) -> tuple[dict, np.ndarray]:
+    def _init_variables(self) -> tuple[dict, npt.NDArray]:
         shape = self._data.z.shape
         res = {
             "Do": np.zeros(shape),
@@ -238,10 +240,12 @@ class DrizzleSolver:
         }
         return res, np.zeros(shape)
 
-    def _calc_beta_z_ratio(self) -> np.ndarray:
+    def _calc_beta_z_ratio(self) -> npt.NDArray:
         return 2 / np.pi * self._data.beta / self._data.z
 
-    def _find_lut_indices(self, ind, dia_init, n_dia, n_widths) -> tuple[int, int]:
+    def _find_lut_indices(
+        self, ind: tuple[int, ...], dia_init: npt.NDArray, n_dia: int, n_widths: int
+    ) -> tuple[int, int]:
         ind_dia = bisect_left(self._data.mie["Do"], dia_init[ind], hi=n_dia - 1)
         ind_width = bisect_left(
             self._width_lut[:, ind_dia],
@@ -250,7 +254,7 @@ class DrizzleSolver:
         )
         return ind_width, ind_dia
 
-    def _solve_drizzle(self, dia_init: np.ndarray) -> None:
+    def _solve_drizzle(self, dia_init: npt.NDArray) -> None:
         drizzle_ind = np.where(self._drizzle_class.drizzle == 1)
         dia_init[drizzle_ind] = self._calc_dia(self._beta_z_ratio[drizzle_ind], k=18.8)
         n_widths, n_dia = self._width_lut.shape[0], len(self._data.mie["Do"])
@@ -277,7 +281,7 @@ class DrizzleSolver:
     def _update_result_tables(
         self,
         ind: tuple,
-        dia: np.ndarray | float,
+        dia: npt.NDArray | float,
         lut_ind: tuple,
     ) -> None:
         self.params["Do"][ind] = dia
@@ -286,11 +290,11 @@ class DrizzleSolver:
 
     @staticmethod
     def _calc_dia(
-        beta_z_ratio: np.ndarray | float,
+        beta_z_ratio: npt.NDArray | float,
         mu: float = 0.0,
         ray: float = 1.0,
         k: float = 1.0,
-    ) -> np.ndarray | float:
+    ) -> npt.NDArray | float:
         """Drizzle diameter calculation.
 
         Args:
@@ -312,8 +316,8 @@ class DrizzleSolver:
     @staticmethod
     def _is_converged(
         ind: tuple,
-        dia: np.ndarray | float,
-        dia_init: np.ndarray,
+        dia: npt.NDArray | float,
+        dia_init: npt.NDArray,
     ) -> bool:
         threshold = 1e-3
         return abs((dia - dia_init[ind]) / dia_init[ind]) < threshold

cloudnetpy/products/epsilon.py

@@ -1,5 +1,6 @@
 from os import PathLike
 from pathlib import Path
+from uuid import UUID
 
 import doppy
 import doppy.netcdf
@@ -20,10 +21,10 @@ def generate_epsilon_from_lidar(
     doppler_lidar_file: str | PathLike,
     doppler_lidar_wind_file: str | PathLike,
     output_file: str | PathLike,
-    uuid: str | None,
-):
+    uuid: str | UUID | None = None,
+) -> UUID:
     sliding_window_in_seconds = 3 * 60
-    uuid = uuid if uuid is not None else get_uuid()
+    uuid = get_uuid(uuid)
     opts = _get_options(doppler_lidar_file)
     opts.period = sliding_window_in_seconds
     vert = _vertical_wind_from_doppler_lidar_file(doppler_lidar_file)
@@ -77,7 +78,7 @@ def generate_epsilon_from_lidar(
             dtype="f4",
         )
 
-        nc.add_attribute("file_uuid", uuid)
+        nc.add_attribute("file_uuid", str(uuid))
         nc.add_attribute("cloudnet_file_type", "epsilon-lidar")
         nc.add_attribute("doppy_version", doppy.__version__)
         nc.add_attribute("cloudnetpy_version", cloudnetpy.__version__)
@@ -163,7 +164,7 @@ def _get_options(doppler_lidar_file: str | PathLike) -> Options:
         raise ValueError(msg)
 
 
-def _infer_pulse_repetition_frequency(range_: npt.NDArray[np.float64]):
+def _infer_pulse_repetition_frequency(range_: npt.NDArray[np.float64]) -> float:
     c = scipy.constants.c
     dist = range_.max() - range_.min()
     round_trip_time = 2 * dist / c

cloudnetpy/products/ier.py

@@ -1,5 +1,8 @@
 """Module for creating Cloudnet ice effective radius file using Z-T method."""
 
+from os import PathLike
+from uuid import UUID
+
 import numpy as np
 from numpy import ma
 
@@ -7,13 +10,14 @@ from cloudnetpy import constants, output
 from cloudnetpy.metadata import MetaData
 from cloudnetpy.products.iwc import DEFINITIONS as IWC_DEFINITION
 from cloudnetpy.products.product_tools import IceClassification, IceSource
+from cloudnetpy.utils import get_uuid
 
 
 def generate_ier(
-    categorize_file: str,
-    output_file: str,
-    uuid: str | None = None,
-) -> str:
+    categorize_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+) -> UUID:
     """Generates Cloudnet ice effective radius product.
 
     This function calculates ice particle effective radius using the Grieche
@@ -55,6 +59,7 @@ def generate_ier(
         from https://doi.org/10.5194/amt-13-5335-2020,
 
     """
+    uuid = get_uuid(uuid)
     product = "ier"
     with IerSource(categorize_file, product) as ier_source:
         ice_classification = IceClassification(categorize_file)
@@ -66,7 +71,8 @@ def generate_ier(
         attributes = output.add_time_attribute(IER_ATTRIBUTES, date)
         attributes = _add_ier_comment(attributes, ier_source)
         output.update_attributes(ier_source.data, attributes)
-        return output.save_product_file(product, ier_source, output_file, uuid)
+        output.save_product_file(product, ier_source, output_file, uuid)
+        return uuid
 
 
 class IerSource(IceSource):

cloudnetpy/products/iwc.py

@@ -1,6 +1,9 @@
 """Module for creating Cloudnet ice water content file using Z-T method."""
 
-import numpy as np
+from os import PathLike
+from uuid import UUID
+
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import output, utils
@@ -10,10 +13,10 @@ from cloudnetpy.products.product_tools import IceClassification, IceSource
 
 
 def generate_iwc(
-    categorize_file: str,
-    output_file: str,
-    uuid: str | None = None,
-) -> str:
+    categorize_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+) -> UUID:
     """Generates Cloudnet ice water content product.
 
     This function calculates ice water content using the so-called Z-T method.
@@ -40,6 +43,7 @@ def generate_iwc(
         J. Appl. Meteor. Climatol., 45, 301–317, https://doi.org/10.1175/JAM2340.1
 
     """
+    uuid = utils.get_uuid(uuid)
     product = "iwc"
     with IwcSource(categorize_file, product) as iwc_source:
         ice_classification = IceClassification(categorize_file)
@@ -53,7 +57,8 @@ def generate_iwc(
         attributes = _add_iwc_comment(attributes, iwc_source)
         attributes = _add_iwc_error_comment(attributes, lwp_prior, bias)
         output.update_attributes(iwc_source.data, attributes)
-        return output.save_product_file(product, iwc_source, output_file, uuid)
+        output.save_product_file(product, iwc_source, output_file, uuid)
+        return uuid
 
 
 class IwcSource(IceSource):
@@ -69,10 +74,12 @@ class IwcSource(IceSource):
         bias = self.getvar("Z_bias") * self.coefficients.Z * 10
         self.append_data(bias, f"{self.product}_bias")
 
-    def append_error(self, ice_classification: IceClassification) -> tuple:
+    def append_error(
+        self, ice_classification: IceClassification
+    ) -> tuple[float, float]:
         """Estimates error of ice water content."""
 
-        def _calc_random_error() -> np.ndarray:
+        def _calc_random_error() -> npt.NDArray:
             scaled_temperature = self.coefficients.ZT * self.temperature
             scaled_temperature += self.coefficients.Z
             return self.getvar("Z_error") * scaled_temperature * 10
@@ -98,7 +105,9 @@ class IwcSource(IceSource):
         return lwp_prior, retrieval_uncertainty
 
 
-def _add_iwc_error_comment(attributes: dict, lwp_prior, uncertainty: float) -> dict:
+def _add_iwc_error_comment(
+    attributes: dict, lwp_prior: float, uncertainty: float
+) -> dict:
     attributes["iwc_error"] = attributes["iwc_error"]._replace(
         comment="This variable is an estimate of the one-standard-deviation random\n"
         "error in ice water content due to both the uncertainty of the retrieval\n"