cloudnetpy 1.49.9__py3-none-any.whl → 1.87.3__py3-none-any.whl

cloudnetpy/model_evaluation/products/model_products.py

@@ -1,7 +1,10 @@
 import importlib
 import logging
+import os.path
+from os import PathLike
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy.datasource import DataSource
@@ -32,12 +35,13 @@ class ModelManager(DataSource):
 
     def __init__(
         self,
-        model_file: str,
+        model_file: str | PathLike,
         model: str,
-        output_file: str,
+        output_file: str | PathLike,
         product: str,
+        *,
         check_file: bool = True,
-    ):
+    ) -> None:
         super().__init__(model_file)
         self.model = model
         self.model_info = MODELS[model]
@@ -52,31 +56,33 @@ class ModelManager(DataSource):
         self.wind = self._calculate_wind_speed()
         self.resolution_h = self._get_horizontal_resolution()
 
-    def _read_cycle_name(self, model_file: str):
-        """Get cycle name from model_metadata.py for saving variable name(s)"""
+    def _read_cycle_name(self, model_file: str | PathLike) -> str:
+        """Get cycle name from model_metadata.py for saving variable name(s)."""
+        basename = os.path.basename(model_file)
         try:
             cycles = self.model_info.cycle
             if cycles is None:
                 return ""
             cycles_split = [x.strip() for x in cycles.split(",")]
             for cycle in cycles_split:
-                if cycle in model_file:
+                if cycle in basename:
                     return f"_{cycle}"
         except AttributeError:
             return ""
         return ""
 
-    def _generate_products(self):
-        """Process needed data of model to a ModelManager object"""
-        cls = getattr(importlib.import_module(__name__), "ModelManager")
+    def _generate_products(self) -> None:
+        """Process needed data of model to a ModelManager object."""
+        cls = importlib.import_module(__name__).ModelManager
         try:
             name = f"_get_{self._product}"
             getattr(cls, name)(self)
-        except AttributeError as e:
-            logging.error(f"Invalid product name: {e}")
+        except AttributeError:
+            msg = f"Invalid product name: {self._product}"
+            logging.exception(msg)
             raise
 
-    def _get_cf(self):
+    def _get_cf(self) -> None:
         """Collect cloud fraction straight from model file."""
         cf_name = self.get_model_var_names(("cf",))[0]
         cf = self.getvar(cf_name)
@@ -85,14 +91,14 @@ class ModelManager(DataSource):
         self.append_data(cf, f"{self.model}{self.cycle}_cf")
         self.keys[self._product] = f"{self.model}{self.cycle}_cf"
 
-    def _get_iwc(self):
-        iwc = self.get_water_continent("iwc")
+    def _get_iwc(self) -> None:
+        iwc = self.get_water_content("iwc")
         iwc[iwc < 1e-7] = ma.masked
         self.append_data(iwc, f"{self.model}{self.cycle}_iwc")
         self.keys[self._product] = f"{self.model}{self.cycle}_iwc"
 
-    def _get_lwc(self):
-        lwc = self.get_water_continent("lwc")
+    def _get_lwc(self) -> None:
+        lwc = self.get_water_content("lwc")
         lwc[lwc < 1e-5] = ma.masked
         self.append_data(lwc, f"{self.model}{self.cycle}_lwc")
         self.keys[self._product] = f"{self.model}{self.cycle}_lwc"
@@ -104,7 +110,7 @@ class ModelManager(DataSource):
             var.append(VARIABLES[arg].long_name)
         return var
 
-    def get_water_continent(self, var: str) -> np.ndarray:
+    def get_water_content(self, var: str) -> npt.NDArray:
         p_name = self.get_model_var_names(("p",))[0]
         t_name = self.get_model_var_names(("T",))[0]
         lwc_name = self.get_model_var_names((var,))[0]
@@ -117,16 +123,20 @@ class ModelManager(DataSource):
         return wc
 
     @staticmethod
-    def _calc_water_content(q: np.ndarray, p: np.ndarray, t: np.ndarray) -> np.ndarray:
+    def _calc_water_content(
+        q: npt.NDArray, p: npt.NDArray, t: npt.NDArray
+    ) -> npt.NDArray:
         return q * p / (287 * t)
 
-    def _add_variables(self):
-        """Add basic variables off model and cycle"""
+    def _add_variables(self) -> None:
+        """Add basic variables off model and cycle."""
 
-        def _add_common_variables():
-            """Model variables that are always the same within cycles"""
+        def _add_common_variables() -> None:
+            """Model variables that are always the same within cycles."""
             wanted_vars = self.model_vars.common_var
-            assert wanted_vars is not None
+            if wanted_vars is None:
+                msg = f"Model {self.model} has no common variables"
+                raise ValueError(msg)
             wanted_vars_split = [x.strip() for x in wanted_vars.split(",")]
             for var in wanted_vars_split:
                 if var in self.dataset.variables:
@@ -135,10 +145,12 @@ class ModelManager(DataSource):
                         data = self.cut_off_extra_levels(self.dataset.variables[var][:])
                     self.append_data(data, f"{var}")
 
-        def _add_cycle_variables():
-            """Add cycle depending variables"""
+        def _add_cycle_variables() -> None:
+            """Add cycle depending variables."""
             wanted_vars = self.model_vars.cycle_var
-            assert wanted_vars is not None
+            if wanted_vars is None:
+                msg = f"Model {self.model} has no cycle variables"
+                raise ValueError(msg)
             wanted_vars_split = [x.strip() for x in wanted_vars.split(",")]
             for var in wanted_vars_split:
                 if var in self.dataset.variables:
@@ -153,21 +165,17 @@ class ModelManager(DataSource):
             _add_common_variables()
         _add_cycle_variables()
 
-    def cut_off_extra_levels(self, data: np.ndarray) -> np.ndarray:
-        """Remove unused levels (over 22km) from model data"""
+    def cut_off_extra_levels(self, data: npt.NDArray) -> npt.NDArray:
+        """Remove unused levels (over 22km) from model data."""
         try:
             level = self.model_info.level
         except KeyError:
             return data
 
-        if data.ndim > 1:
-            data = data[:, :level]
-        else:
-            data = data[:level]
-        return data
+        return data[:, :level] if data.ndim > 1 else data[:level]
 
-    def _calculate_wind_speed(self) -> np.ndarray:
-        """Real wind from x- and y-components"""
+    def _calculate_wind_speed(self) -> npt.NDArray:
+        """Real wind from x- and y-components."""
         u = self.getvar("uwind")
         v = self.getvar("vwind")
         u = self.cut_off_extra_levels(u)

cloudnetpy/model_evaluation/products/observation_products.py

@@ -1,12 +1,14 @@
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
+from os import PathLike
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy import utils
 from cloudnetpy.datasource import DataSource
-from cloudnetpy.products.product_tools import CategorizeBits
+from cloudnetpy.products.product_tools import CategorizeBits, CategoryBits
 
 
 class ObservationManager(DataSource):
@@ -24,7 +26,7 @@ class ObservationManager(DataSource):
         should be processed using CloudnetPy for this class to work properly.
     """
 
-    def __init__(self, obs: str, obs_file: str):
+    def __init__(self, obs: str, obs_file: str | PathLike) -> None:
         super().__init__(obs_file)
         self.obs = obs
         self._file = obs_file
@@ -42,22 +44,23 @@ class ObservationManager(DataSource):
             0,
             0,
             0,
+            tzinfo=timezone.utc,
         )
 
-    def _get_radar_frequency(self) -> np.ndarray | None:
+    def _get_radar_frequency(self) -> npt.NDArray | None:
         try:
             return self.getvar("radar_frequency")
         except (KeyError, RuntimeError):
             return None
 
-    def _get_z_sensitivity(self) -> np.ndarray | None:
+    def _get_z_sensitivity(self) -> npt.NDArray | None:
         try:
             return self.getvar("Z_sensitivity")
         except (KeyError, RuntimeError):
             return None
 
-    def _generate_product(self):
-        """Process needed data of observation to a ObservationManager object"""
+    def _generate_product(self) -> None:
+        """Process needed data of observation to a ObservationManager object."""
         try:
             if self.obs == "cf":
                 self.append_data(self._generate_cf(), "cf")
@@ -66,31 +69,31 @@ class ObservationManager(DataSource):
                 if self.obs == "iwc":
                     self._generate_iwc_masks()
             self.append_data(self.getvar("height"), "height")
-        except (KeyError, RuntimeError) as e:
-            logging.error(f"Invalid product name: {e}")
+        except (KeyError, RuntimeError):
+            msg = f"Failed to read {self.obs} from {self._file}"
+            logging.exception(msg)
             raise
 
-    def _generate_cf(self) -> np.ndarray:
-        """Generates cloud fractions using categorize bits and masking conditions"""
+    def _generate_cf(self) -> npt.NDArray:
+        """Generates cloud fractions using categorize bits and masking conditions."""
         categorize_bits = CategorizeBits(self._file)
         cloud_mask = self._classify_basic_mask(categorize_bits.category_bits)
-        cloud_mask = self._mask_cloud_bits(cloud_mask)
-        return cloud_mask
+        return self._mask_cloud_bits(cloud_mask)
 
     @staticmethod
-    def _classify_basic_mask(bits: dict) -> np.ndarray:
-        cloud_mask = bits["droplet"] + bits["falling"] * 2
-        cloud_mask[bits["falling"] & bits["cold"]] = (
-            cloud_mask[bits["falling"] & bits["cold"]] + 2
+    def _classify_basic_mask(bits: CategoryBits) -> npt.NDArray:
+        cloud_mask = bits.droplet + bits.falling * 2
+        cloud_mask[bits.falling & bits.freezing] = (
+            cloud_mask[bits.falling & bits.freezing] + 2
         )
-        cloud_mask[bits["aerosol"]] = 6
-        cloud_mask[bits["insect"]] = 7
-        cloud_mask[bits["aerosol"] & bits["insect"]] = 8
+        cloud_mask[bits.aerosol] = 6
+        cloud_mask[bits.insect] = 7
+        cloud_mask[bits.aerosol & bits.insect] = 8
         return cloud_mask
 
     @staticmethod
-    def _mask_cloud_bits(cloud_mask: np.ndarray) -> np.ndarray:
-        """Creates cloud fraction"""
+    def _mask_cloud_bits(cloud_mask: npt.NDArray) -> npt.NDArray:
+        """Creates cloud fraction."""
         for i in [1, 3, 4, 5]:
             cloud_mask[cloud_mask == i] = 1
         for i in [2, 6, 7, 8]:
@@ -98,28 +101,30 @@ class ObservationManager(DataSource):
         return cloud_mask
 
     def _check_rainrate(self) -> bool:
-        """Check if rainrate in file"""
+        """Check if rainrate in file."""
         try:
             self.getvar("rainrate")
-            return True
-        except RuntimeError:
+        except KeyError:
             return False
+        return True
 
     def _get_rainrate_threshold(self) -> int:
-        assert self.radar_freq is not None
+        if self.radar_freq is None:
+            msg = "Radar frequency not found from file"
+            raise RuntimeError(msg)
         wband = utils.get_wl_band(float(self.radar_freq))
         rainrate_threshold = 8
-        if 90 < wband < 100:
+        if wband == "W":
             rainrate_threshold = 2
         return rainrate_threshold
 
-    def _rain_index(self) -> np.ndarray:
+    def _rain_index(self) -> npt.NDArray:
         rainrate = self.getvar("rainrate")
         rainrate_threshold = self._get_rainrate_threshold()
         return rainrate > rainrate_threshold
 
     def _generate_iwc_masks(self) -> None:
-        """Generates ice water content variables with different masks"""
+        """Generates ice water content variables with different masks."""
         # TODO: Differences with CloudnetPy (status=2) and Legacy data (status=3)
         iwc = self.getvar(self.obs)
         iwc_status = self.getvar("iwc_retrieval_status")
@@ -127,21 +132,22 @@ class ObservationManager(DataSource):
         self._get_rain_iwc(iwc_status)
         self._mask_iwc(iwc, iwc_status)
 
-    def _mask_iwc(self, iwc: np.ndarray, iwc_status: np.ndarray) -> None:
-        """Leaves only reliable data and corrected liquid attenuation"""
+    def _mask_iwc(self, iwc: npt.NDArray, iwc_status: npt.NDArray) -> None:
+        """Leaves only reliable data and corrected liquid attenuation."""
         iwc_mask = ma.copy(iwc)
         iwc_mask[np.bitwise_and(iwc_status != 1, iwc_status != 2)] = ma.masked
         self.append_data(iwc_mask, "iwc")
 
-    def _mask_iwc_att(self, iwc: np.ndarray, iwc_status: np.ndarray) -> None:
+    def _mask_iwc_att(self, iwc: npt.NDArray, iwc_status: npt.NDArray) -> None:
         """Leaves only where reliable data, corrected liquid attenuation
-        and uncorrected liquid attenuation"""
+        and uncorrected liquid attenuation.
+        """
         iwc_att = ma.copy(iwc)
         iwc_att[iwc_status > 3] = ma.masked
         self.append_data(iwc_att, "iwc_att")
 
-    def _get_rain_iwc(self, iwc_status: np.ndarray) -> None:
-        """Finds columns where is rain, return boolean of x-axis shape"""
+    def _get_rain_iwc(self, iwc_status: npt.NDArray) -> None:
+        """Finds columns where is rain, return boolean of x-axis shape."""
         iwc_rain = np.zeros(iwc_status.shape, dtype=bool)
         iwc_rain[iwc_status == 5] = 1
         iwc_rain = np.any(iwc_rain, axis=1)

cloudnetpy/model_evaluation/products/product_resampling.py

@@ -1,4 +1,6 @@
 import logging
+from os import PathLike
+from uuid import UUID
 
 import cloudnetpy.model_evaluation.products.tools as tl
 from cloudnetpy.model_evaluation.file_handler import (
@@ -12,22 +14,25 @@ from cloudnetpy.model_evaluation.products.grid_methods import ProductGrid
 from cloudnetpy.model_evaluation.products.model_products import ModelManager
 from cloudnetpy.model_evaluation.products.observation_products import ObservationManager
 from cloudnetpy.model_evaluation.utils import file_exists
+from cloudnetpy.utils import get_uuid
 
 
 def process_L3_day_product(
     model: str,
     obs: str,
-    model_files: list,
-    product_file: str,
-    output_file: str,
-    uuid: str | None = None,
+    model_files: list[str | PathLike],
+    product_file: str | PathLike,
+    output_file: str | PathLike,
+    uuid: str | UUID | None = None,
+    *,
     overwrite: bool = False,
-):
+) -> UUID:
     """Main function to generate downsample of observations to match model grid.
 
     This function will generate a L3 product nc-file. It includes the information of
     downsampled observation products for each model cycles and model products
     and other variables of each cycles.
+
     Args:
         model (str): Name of model
         obs (str): Name of product to generate
@@ -61,11 +66,16 @@ def process_L3_day_product(
         >>> process_L3_day_product(model, product, [model_file], input_file,
         output_file)
     """
+    uuid = get_uuid(uuid)
     product_obj = ObservationManager(obs, product_file)
     tl.check_model_file_list(model, model_files)
     for m_file in model_files:
         model_obj = ModelManager(
-            m_file, model, output_file, obs, check_file=not overwrite
+            m_file,
+            model,
+            output_file,
+            obs,
+            check_file=not overwrite,
         )
         try:
             AdvanceProductMethods(model_obj, m_file, product_obj)
@@ -76,7 +86,7 @@ def process_L3_day_product(
         update_attributes(model_obj.data, attributes)
         if not file_exists(output_file) or overwrite:
             tl.add_date(model_obj, product_obj)
-            uuid = save_downsampled_file(
+            save_downsampled_file(
                 f"{obs}_{model}",
                 output_file,
                 (model_obj, product_obj),

cloudnetpy/model_evaluation/products/tools.py

@@ -1,27 +1,32 @@
 import datetime
 import logging
+import os.path
+from collections.abc import Sequence
 from datetime import timedelta
+from os import PathLike
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 from cloudnetpy.model_evaluation.products.model_products import ModelManager
 from cloudnetpy.model_evaluation.products.observation_products import ObservationManager
 
 
-def check_model_file_list(name: str, models: list) -> None:
-    """Check that files in models are from same model and date"""
+def check_model_file_list(name: str, models: Sequence[str | PathLike]) -> None:
+    """Check that files in models are from same model and date."""
     for m in models:
-        if name not in m:
+        if name not in os.path.basename(m):
             logging.error("Invalid model file set")
-            raise AttributeError(f"{m} not from {name}")
+            msg = f"{m} not from {name}"
+            raise AttributeError(msg)
 
 
-def time2datetime(time: np.ndarray, date: datetime.datetime) -> np.ndarray:
+def time2datetime(time: npt.NDArray, date: datetime.datetime) -> npt.NDArray:
     return np.asarray([date + timedelta(hours=float(t)) for t in time])
 
 
-def rebin_edges(arr: np.ndarray) -> np.ndarray:
+def rebin_edges(arr: npt.NDArray) -> npt.NDArray:
     """Rebins array bins by half and adds boundaries."""
     new_arr = [(arr[i] + arr[i + 1]) / 2 for i in range(len(arr) - 1)]
     new_arr.insert(0, arr[0] - ((arr[0] + arr[1]) / 2))
@@ -30,9 +35,11 @@ def rebin_edges(arr: np.ndarray) -> np.ndarray:
 
 
 def calculate_advection_time(
-    resolution: int, wind: ma.MaskedArray, sampling: int
-) -> np.ndarray:
-    """Calculates time which variable takes to go through the time window
+    resolution: int,
+    wind: ma.MaskedArray,
+    sampling: int,
+) -> npt.NDArray:
+    """Calculates time which variable takes to go through the time window.
 
     Notes:
         Wind speed is stronger in upper levels, so advection time is more
@@ -40,8 +47,6 @@ def calculate_advection_time(
         but visible in a tropics.
 
         sampling = 1 -> hour, sampling 1/6 -> 10min
-
-    References:
     """
     t_adv = resolution * 1000 / wind / 60**2
     t_adv[t_adv.mask] = 0
@@ -49,8 +54,12 @@ def calculate_advection_time(
     return np.asarray([[timedelta(hours=float(t)) for t in time] for time in t_adv])
 
 
-def get_1d_indices(window: tuple, data: np.ndarray, mask: np.ndarray | None = None):
-    indices = (window[0] <= data) & (data < window[-1])
+def get_1d_indices(
+    window: tuple,
+    data: npt.NDArray,
+    mask: npt.NDArray | None = None,
+) -> npt.NDArray:
+    indices: npt.NDArray = np.array((window[0] <= data) & (data < window[-1]))
     if mask is not None:
         indices[mask] = ma.masked
     return indices
@@ -59,17 +68,17 @@ def get_1d_indices(window: tuple, data: np.ndarray, mask: np.ndarray | None = No
 def get_adv_indices(
     model_t: int,
     adv_t: float,
-    data: np.ndarray,
-    mask: np.ndarray | None = None,
-):
+    data: npt.NDArray,
+    mask: npt.NDArray | None = None,
+) -> npt.NDArray:
     adv_indices = ((model_t - adv_t / 2) <= data) & (data < (model_t + adv_t / 2))
     if mask is not None:
         adv_indices[mask] = ma.masked
     return adv_indices
 
 
-def get_obs_window_size(ind_x: np.ndarray, ind_y: np.ndarray) -> tuple | None:
-    """Returns shape (tuple) of window area, where values are True"""
+def get_obs_window_size(ind_x: npt.NDArray, ind_y: npt.NDArray) -> tuple | None:
+    """Returns shape (tuple) of window area, where values are True."""
     x = np.where(ind_x)[0]
     y = np.where(ind_y)[0]
     if np.any(x) and np.any(y):
@@ -82,6 +91,6 @@ def add_date(model_obj: ModelManager, obs_obj: ObservationManager) -> None:
         model_obj.date.append(getattr(obs_obj.dataset, a))
 
 
-def average_column_sum(data: np.ndarray) -> np.ndarray:
-    """Returns average sum of columns which have any data"""
+def average_column_sum(data: npt.NDArray) -> npt.NDArray:
+    """Returns average sum of columns which have any data."""
     return np.nanmean(np.nansum(data, 1) > 0)

cloudnetpy/model_evaluation/statistics/statistical_methods.py

@@ -3,13 +3,14 @@ import os
 import sys
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 
 class DayStatistics:
-    """Class for calculating statistical analysis of day scale products
+    """Class for calculating statistical analysis of day scale products.
 
     Class generates one statistical method at the time with given model data
     and observation data of wanted product.
@@ -20,8 +21,8 @@ class DayStatistics:
             done with. A list includes observed product name (str), model variable (str)
             name and a name of observation variable (str). Example: ['cf', 'ECMWF',
             'Cloud fraction by volume']
-        model (np.ndarray): Ndarray of model simulation of product
-        observation (np.ndarray): Ndrray of Downsampled observation of product
+        model (npt.NDArray): Ndarray of model simulation of product
+        observation (npt.NDArray): Ndrray of Downsampled observation of product
 
     Raises:
         RuntimeError: A function of given method not found
@@ -44,9 +45,9 @@ class DayStatistics:
         self,
         method: str,
         product_info: list,
-        model: np.ndarray,
-        observation: np.ndarray,
-    ):
+        model: npt.NDArray,
+        observation: npt.NDArray,
+    ) -> None:
         self.method = method
         self.product = product_info
         self.model_data = model
@@ -72,20 +73,22 @@ class DayStatistics:
             full_name = "vertical_profile"
         return full_name, params
 
-    def _generate_day_statistics(self):
+    def _generate_day_statistics(self) -> None:
         full_name, params = self._get_method_attr()
         cls = __import__("statistical_methods")
         try:
             self.model_stat, self.observation_stat = getattr(cls, f"{full_name}")(
-                *params
+                *params,
             )
-            self.title = getattr(cls, "day_stat_title")(self.method, self.product)
-        except RuntimeError as error:
-            logging.error(f"Method {full_name} not found or missing: {error}")
+            self.title = cls.day_stat_title(self.method, self.product)
+        except RuntimeError:
+            msg = f"Failed to calculate {self.method} of {self.product[0]}"
+            logging.exception(msg)
 
 
 def relative_error(
-    model: ma.MaskedArray, observation: ma.MaskedArray
+    model: ma.MaskedArray,
+    observation: ma.MaskedArray,
 ) -> tuple[float, str]:
     model, observation = combine_masked_indices(model, observation)
     error = ((model - observation) / observation) * 100
@@ -93,7 +96,8 @@ def relative_error(
 
 
 def absolute_error(
-    model: ma.MaskedArray, observation: ma.MaskedArray
+    model: ma.MaskedArray,
+    observation: ma.MaskedArray,
 ) -> tuple[float, str]:
     model, observation = combine_masked_indices(model, observation)
     error = (observation - model) * 100
@@ -101,9 +105,10 @@ def absolute_error(
 
 
 def combine_masked_indices(
-    model: ma.MaskedArray, observation: ma.MaskedArray
+    model: ma.MaskedArray,
+    observation: ma.MaskedArray,
 ) -> tuple[ma.MaskedArray, ma.MaskedArray]:
-    """Connects two array masked indices to one and add in two array same mask"""
+    """Connects two array masked indices to one and add in two array same mask."""
     observation[np.where(np.isnan(observation))] = ma.masked
     model[model < np.min(observation)] = ma.masked
     combine_mask = model.mask + observation.mask
@@ -113,9 +118,10 @@ def combine_masked_indices(
 
 
 def calc_common_area_sum(
-    model: ma.MaskedArray, observation: ma.MaskedArray
+    model: ma.MaskedArray,
+    observation: ma.MaskedArray,
 ) -> tuple[float, str]:
-    def _indices_of_mask_sum():
+    def _indices_of_mask_sum() -> float:
         # Calculate percentage value of common area of indices from two arrays.
         # Results is total number of common indices with value
         observation[np.where(np.isnan(observation))] = ma.masked
@@ -131,17 +137,21 @@ def calc_common_area_sum(
 
 
 def histogram(
-    product: list, model: ma.MaskedArray, observation: ma.MaskedArray
+    product: list,
+    model: ma.MaskedArray,
+    observation: ma.MaskedArray,
 ) -> tuple:
     if "cf" in product:
         model = ma.round(model[~model.mask].data, decimals=1).flatten()
         observation = ma.round(
-            observation[~observation.mask].data, decimals=1
+            observation[~observation.mask].data,
+            decimals=1,
         ).flatten()
     else:
         model = ma.round(model[~model.mask].data, decimals=6).flatten()
         observation = ma.round(
-            observation[~observation.mask].data, decimals=6
+            observation[~observation.mask].data,
+            decimals=6,
         ).flatten()
     observation = observation[~np.isnan(observation)]
     hist_bins = np.histogram(observation, density=True)[-1]

cloudnetpy/model_evaluation/tests/e2e/conftest.py

@@ -3,11 +3,11 @@ import pytest
 args = ["site", "date", "input", "output", "full_path"]
 
 
-def pytest_addoption(parser):
+def pytest_addoption(parser) -> None:
     for arg in args:
         parser.addoption(f"--{arg}", action="store")
 
 
-@pytest.fixture
-def params(request):
+@pytest.fixture()
+def params(request) -> dict:
     return {arg: request.config.getoption(f"--{arg}") for arg in args}