cloudnetpy 1.61.15__py3-none-any.whl → 1.61.17__py3-none-any.whl

cloudnetpy/instruments/weather_station.py

@@ -47,12 +47,16 @@ def ws2nc(
         ws: WS
         if site_meta["name"] == "Palaiseau":
             ws = PalaiseauWS(weather_station_file, site_meta)
+        elif site_meta["name"] == "Bucharest":
+            ws = BucharestWS(weather_station_file, site_meta)
         elif site_meta["name"] == "Granada":
             ws = GranadaWS(weather_station_file, site_meta)
         elif site_meta["name"] == "Kenttärova":
             ws = KenttarovaWS(weather_station_file, site_meta)
         elif site_meta["name"] == "Hyytiälä":
             ws = HyytialaWS(weather_station_file, site_meta)
+        elif site_meta["name"] == "Galați":
+            ws = GalatiWS(weather_station_file, site_meta)
         else:
             msg = "Unsupported site"
             raise ValueError(msg)  # noqa: TRY301
@@ -66,6 +70,7 @@ def ws2nc(
         ws.convert_pressure()
         ws.convert_rainfall_rate()
         ws.convert_rainfall_amount()
+        ws.normalize_rainfall_amount()
         ws.calculate_rainfall_amount()
         attributes = output.add_time_attribute(ATTRIBUTES, ws.date)
         output.update_attributes(ws.data, attributes)
@@ -75,9 +80,11 @@ def ws2nc(
 
 
 class WS(CloudnetInstrument):
-    def __init__(self):
+    def __init__(self, site_meta: dict):
         super().__init__()
         self._data: dict
+        self.site_meta = site_meta
+        self.instrument = instruments.GENERIC_WEATHER_STATION
 
     date: list[str]
 
@@ -111,6 +118,15 @@ class WS(CloudnetInstrument):
                 x for ind, x in enumerate(self._data[key]) if ind in valid_ind
             ]
 
+    @staticmethod
+    def format_data(data: dict) -> dict:
+        for key, value in data.items():
+            new_value = np.array(value)
+            if key != "time":
+                new_value = ma.masked_where(np.isnan(new_value), new_value)
+            data[key] = new_value
+        return data
+
     def convert_temperature_and_humidity(self) -> None:
         temperature_kelvins = atmos_utils.c2k(self.data["air_temperature"][:])
         self.data["air_temperature"].data = temperature_kelvins
@@ -123,6 +139,17 @@ class WS(CloudnetInstrument):
     def convert_pressure(self) -> None:
         self.data["air_pressure"].data = self.data["air_pressure"][:] * 100  # hPa to Pa
 
+    def normalize_rainfall_amount(self) -> None:
+        if "rainfall_amount" in self.data:
+            amount = self.data["rainfall_amount"][:]
+            offset = 0
+            for i in range(1, len(amount)):
+                if amount[i] + offset < amount[i - 1]:
+                    offset += amount[i - 1]
+                amount[i] += offset
+            amount -= amount[0]
+            self.data["rainfall_amount"].data = amount
+
     def convert_time(self) -> None:
         pass
 
@@ -132,50 +159,30 @@ class WS(CloudnetInstrument):
 
 class PalaiseauWS(WS):
     def __init__(self, filenames: list[str], site_meta: dict):
-        super().__init__()
-        if len(filenames) != 1:
-            raise ValueError
-        self.filename = filenames[0]
-        self.site_meta = site_meta
-        self.instrument = instruments.GENERIC_WEATHER_STATION
+        super().__init__(site_meta)
+        self.filenames = filenames
         self._data = self._read_data()
 
     def _read_data(self) -> dict:
         timestamps, values, header = [], [], []
-        with open(self.filename, encoding="latin-1") as f:
-            data = f.readlines()
-        for row in data:
-            splat = row.split()
-            try:
-                timestamp = datetime.datetime.strptime(
-                    splat[0],
-                    "%Y-%m-%dT%H:%M:%SZ",
-                ).replace(tzinfo=datetime.timezone.utc)
-                temp: list[str | float] = list(splat)
-                temp[1:] = [float(x) for x in temp[1:]]
-                values.append(temp)
-                timestamps.append(timestamp)
-            except ValueError:
-                header.append("".join(splat))
-
-        # Simple validation for now:
-        expected_identifiers = [
-            "DateTime(yyyy-mm-ddThh:mm:ssZ)",
-            "Windspeed(m/s)",
-            "Winddirection(degres)",
-            "Airtemperature(°C)",
-            "Relativehumidity(%)",
-            "Pressure(hPa)",
-            "Precipitationrate(mm/min)",
-            "24-hrcumulatedprecipitationsince00UT(mm)",
-        ]
-        column_titles = [row for row in header if "Col." in row]
-        error_msg = "Unexpected weather station file format"
-        if len(column_titles) != len(expected_identifiers):
-            raise ValueError(error_msg)
-        for title, identifier in zip(column_titles, expected_identifiers, strict=True):
-            if identifier not in title:
-                raise ValueError(error_msg)
+        for filename in self.filenames:
+            with open(filename, encoding="latin-1") as f:
+                data = f.readlines()
+            for row in data:
+                if not (columns := row.split()):
+                    continue
+                if row.startswith("#"):
+                    header_row = "".join(columns)
+                    if header_row not in header:
+                        header.append(header_row)
+                else:
+                    timestamp = datetime.datetime.strptime(
+                        columns[0], "%Y-%m-%dT%H:%M:%SZ"
+                    ).replace(tzinfo=datetime.timezone.utc)
+                    values.append([timestamp] + [float(x) for x in columns[1:]])
+                    timestamps.append(timestamp)
+
+        self._validate_header(header)
         return {"time": timestamps, "values": values}
 
     def convert_time(self) -> None:
@@ -212,15 +219,39 @@ class PalaiseauWS(WS):
             self.data["rainfall_amount"][:] / 1000
         )  # mm -> m
 
+    @staticmethod
+    def _validate_header(header: list[str]) -> None:
+        expected_identifiers = [
+            "DateTime(yyyy-mm-ddThh:mm:ssZ)",
+            "Windspeed(m/s)",
+            "Winddirection(deg",
+            "Airtemperature",
+            "Relativehumidity(%)",
+            "Pressure(hPa)",
+            "Precipitationrate(mm/min)",
+            "precipitation",
+        ]
+        column_titles = [row for row in header if "Col." in row]
+        error_msg = "Unexpected weather station file format"
+        if len(column_titles) != len(expected_identifiers):
+            raise ValueError(error_msg)
+        for title, identifier in zip(column_titles, expected_identifiers, strict=True):
+            if identifier not in title:
+                raise ValueError(error_msg)
+
+
+class BucharestWS(PalaiseauWS):
+    def convert_rainfall_rate(self) -> None:
+        rainfall_rate = self.data["rainfall_rate"][:]
+        self.data["rainfall_rate"].data = rainfall_rate * MM_H_TO_M_S
+
 
 class GranadaWS(WS):
     def __init__(self, filenames: list[str], site_meta: dict):
         if len(filenames) != 1:
             raise ValueError
-        super().__init__()
+        super().__init__(site_meta)
         self.filename = filenames[0]
-        self.site_meta = site_meta
-        self.instrument = instruments.GENERIC_WEATHER_STATION
         self._data = self._read_data()
 
     def _read_data(self) -> dict:
@@ -264,10 +295,8 @@ class GranadaWS(WS):
 
 class KenttarovaWS(WS):
     def __init__(self, filenames: list[str], site_meta: dict):
-        super().__init__()
+        super().__init__(site_meta)
         self.filenames = filenames
-        self.site_meta = site_meta
-        self.instrument = instruments.GENERIC_WEATHER_STATION
         self._data = self._read_data()
 
     def _read_data(self) -> dict:
@@ -302,12 +331,7 @@ class KenttarovaWS(WS):
                 merged = {key: [*merged[key], *data[key]] for key in merged}
             else:
                 merged = data
-        for key, value in merged.items():
-            new_value = np.array(value)
-            if key != "time":
-                new_value = ma.masked_where(np.isnan(new_value), new_value)
-            merged[key] = new_value
-        return merged
+        return self.format_data(merged)
 
     def convert_rainfall_rate(self) -> None:
         # Rainfall rate is 10-minute averaged in mm h-1
@@ -320,18 +344,15 @@ class KenttarovaWS(WS):
 
 
 class HyytialaWS(WS):
-    """
-    Hyytiälä rain-gauge variables: a = Pluvio400 and b = Pluvio200.
+    """Hyytiälä rain-gauge variables: a = Pluvio400 and b = Pluvio200.
     E.g.
     - AaRNRT/mm = amount of non-real-time rain total (Pluvio400) [mm]
-    - BbRT/mm = Bucket content in real-time (Pluvio200) [mm]
+    - BbRT/mm = Bucket content in real-time (Pluvio200) [mm].
     """
 
     def __init__(self, filenames: list[str], site_meta: dict):
-        super().__init__()
+        super().__init__(site_meta)
         self.filename = filenames[0]
-        self.site_meta = site_meta
-        self.instrument = instruments.GENERIC_WEATHER_STATION
         self._data = self._read_data()
 
     def _read_data(self) -> dict:
@@ -381,12 +402,7 @@ class HyytialaWS(WS):
             "wind_direction": raw_data["WD/ds"],
             "rainfall_rate": raw_data["AaNRT/mm"],
         }
-        for key, value in data.items():
-            new_value = np.array(value)
-            if key != "time":
-                new_value = ma.masked_where(np.isnan(new_value), new_value)
-            data[key] = new_value
-        return data
+        return self.format_data(data)
 
     def convert_pressure(self) -> None:
         self.data["air_pressure"].data = (
@@ -394,6 +410,43 @@ class HyytialaWS(WS):
         )  # kPa to Pa
 
 
+class GalatiWS(WS):
+    def __init__(self, filenames: list[str], site_meta: dict):
+        super().__init__(site_meta)
+        self.filename = filenames[0]
+        self._data = self._read_data()
+
+    def _read_data(self) -> dict:
+        with open(self.filename, newline="") as f:
+            reader = csv.DictReader(f)
+            raw_data: dict = {key: [] for key in reader.fieldnames}  # type: ignore[union-attr]
+            for row in reader:
+                for key, value in row.items():
+                    parsed_value: float | datetime.datetime
+                    if key == "TimeStamp":
+                        parsed_value = datetime.datetime.strptime(
+                            value, "%Y-%m-%d %H:%M:%S.%f"
+                        )
+                    else:
+                        try:
+                            parsed_value = float(value)
+                        except ValueError:
+                            parsed_value = math.nan
+                    raw_data[key].append(parsed_value)
+        data = {
+            "time": raw_data["TimeStamp"],
+            "air_temperature": raw_data["Temperature"],
+            "relative_humidity": raw_data["RH"],
+            "air_pressure": raw_data["Atmospheric_pressure"],
+            "rainfall_rate": raw_data["Precipitations"],
+        }
+        return self.format_data(data)
+
+    def convert_pressure(self) -> None:
+        mmHg2Pa = 133.322
+        self.data["air_pressure"].data = self.data["air_pressure"][:] * mmHg2Pa
+
+
 ATTRIBUTES = {
     "rainfall_amount": MetaData(
         long_name="Rainfall amount",

cloudnetpy/model_evaluation/file_handler.py

@@ -145,7 +145,7 @@ def _augment_global_attributes(root_group: netCDF4.Dataset) -> None:
 
 
 def _add_source(root_ground: netCDF4.Dataset, objects: tuple, files: tuple) -> None:
-    """Generates source info for multiple files"""
+    """Generates source info for multiple files."""
     model, obs = objects
     model_files, obs_file = files
     source = f"Observation file: {os.path.basename(obs_file)}"
@@ -160,7 +160,7 @@ def _add_source(root_ground: netCDF4.Dataset, objects: tuple, files: tuple) -> N
 
 
 def add_time_attribute(date: datetime) -> dict:
-    """ "Adds time attribute with correct units.
+    """Adds time attribute with correct units.
 
     Args:
         attributes: Attributes of variables.

cloudnetpy/model_evaluation/metadata.py

@@ -114,7 +114,7 @@ REGRID_PRODUCT_ATTRIBUTES = {
         comment=(
             "Cloud fraction generated from observations and by volume,\n"
             "averaged onto the models grid with height and time. Volume is\n"
-            "space withing four grid points."
+            "space within four grid points."
         ),
     ),
     "cf_A": MetaData(

cloudnetpy/model_evaluation/plotting/plot_tools.py

@@ -13,7 +13,7 @@ def parse_wanted_names(
     *,
     advance: bool = False,
 ) -> tuple[list, list]:
-    """Returns standard and advection lists of product types to plot"""
+    """Returns standard and advection lists of product types to plot."""
     if variables:
         names = variables
     else:
@@ -76,7 +76,7 @@ def sort_cycles(names: list, model: str) -> tuple[list, list]:
 
 
 def read_data_characters(nc_file: str, name: str, model: str) -> tuple:
-    """Gets dimensions and data for plotting"""
+    """Gets dimensions and data for plotting."""
     nc = netCDF4.Dataset(nc_file)
     data = nc.variables[name][:]
     data = mask_small_values(data, name)

cloudnetpy/model_evaluation/plotting/plotting.py

@@ -7,9 +7,11 @@ import matplotlib as mpl
 import matplotlib.pyplot as plt
 import netCDF4
 import numpy as np
+from matplotlib.axes import Axes
 from matplotlib.colorbar import Colorbar
 from matplotlib.colors import ListedColormap
 from matplotlib.patches import Patch
+from matplotlib.pyplot import Figure
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 from numpy import ma
 
@@ -187,6 +189,7 @@ def get_group_plots(
         show (bool): Show figure before saving if True
         cycle (str): Name of cycle if exists
         title (bool): True or False if wanted to add title to subfig
+        include_xlimits (bool): Show labels at the ends of x-axis
     """
     fig, ax = initialize_figure(len(names))
     model_run = model
@@ -248,6 +251,7 @@ def get_pair_plots(
         show (bool): Show figure before saving if True
         cycle (str): Name of cycle if exists
         title (bool): True or False if wanted add title to subfig
+        include_xlimits (bool): Show labels at the ends of x-axis
     """
     variable_info = ATTRIBUTES[product]
     model_ax = names[0]
@@ -306,6 +310,7 @@ def get_single_plots(
         show (bool): Show figure before saving if True
         cycle (str): Name of cycle if exists
         title (bool): True or False if wanted to add title to subfig
+        include_xlimits (bool): Show labels at the ends of x-axis
     """
     figs = []
     axes = []
@@ -387,6 +392,7 @@ def get_statistic_plots(
         image_name (str, optional): Saving name of generated fig
         show (bool): Show figure before saving if True
         cycle (str): Name of cycle if exists
+        title (bool): True or False if wanted to add title to subfig
     """
     model_run = model
     name = ""
@@ -687,8 +693,8 @@ def plot_vertical_profile(
     ax.xaxis.grid(which="major")
 
 
-def initialize_figure(n_subplots: int, stat: str = "") -> tuple:
-    """Set up fig and ax object, if subplot"""
+def initialize_figure(n_subplots: int, stat: str = "") -> tuple[Figure, list[Axes]]:
+    """Set up fig and ax object, if subplot."""
     if n_subplots <= 0:
         n_subplots = 1
     fig, axes = plt.subplots(n_subplots, 1, figsize=(16, 4 + (n_subplots - 1) * 4.8))
@@ -714,7 +720,6 @@ def initialize_figure(n_subplots: int, stat: str = "") -> tuple:
                 right=0.75,
                 hspace=0.2,
             )
-            axes = axes.flatten()
     if stat == "vertical" and n_subplots > 1:
         fig, axes = plt.subplots(
             int(n_subplots / 2),
@@ -731,10 +736,8 @@ def initialize_figure(n_subplots: int, stat: str = "") -> tuple:
             right=0.75,
             hspace=0.16,
         )
-        axes = axes.flatten()
-    if n_subplots == 1:
-        axes = [axes]
-    return fig, axes
+    axes_list = [axes] if isinstance(axes, Axes) else axes.flatten().tolist()
+    return fig, axes_list
 
 
 def init_colorbar(plot, axis) -> Colorbar:
@@ -750,7 +753,7 @@ def _set_title(
     variable_info,
     model_name: str = "",
 ) -> None:
-    """Generates subtitles for different product types"""
+    """Generates subtitles for different product types."""
     parts = field_name.split("_")
     if parts[0] == product:
         title = _get_product_title(variable_info)

cloudnetpy/model_evaluation/products/grid_methods.py

@@ -154,7 +154,7 @@ class ProductGrid:
         x_ind: np.ndarray,
         y_ind: np.ndarray,
     ) -> np.ndarray | None:
-        """Reshapes True observation values to windows shape"""
+        """Reshapes True observation values to windows shape."""
         window_size = tl.get_obs_window_size(x_ind, y_ind)
         if window_size is not None:
             return self._obs_data[ind].reshape(window_size)

cloudnetpy/model_evaluation/products/model_products.py

@@ -54,7 +54,7 @@ class ModelManager(DataSource):
         self.resolution_h = self._get_horizontal_resolution()
 
     def _read_cycle_name(self, model_file: str) -> str:
-        """Get cycle name from model_metadata.py for saving variable name(s)"""
+        """Get cycle name from model_metadata.py for saving variable name(s)."""
         try:
             cycles = self.model_info.cycle
             if cycles is None:
@@ -68,7 +68,7 @@ class ModelManager(DataSource):
         return ""
 
     def _generate_products(self) -> None:
-        """Process needed data of model to a ModelManager object"""
+        """Process needed data of model to a ModelManager object."""
         cls = importlib.import_module(__name__).ModelManager
         try:
             name = f"_get_{self._product}"
@@ -123,10 +123,10 @@ class ModelManager(DataSource):
         return q * p / (287 * t)
 
     def _add_variables(self) -> None:
-        """Add basic variables off model and cycle"""
+        """Add basic variables off model and cycle."""
 
         def _add_common_variables() -> None:
-            """Model variables that are always the same within cycles"""
+            """Model variables that are always the same within cycles."""
             wanted_vars = self.model_vars.common_var
             if wanted_vars is None:
                 msg = f"Model {self.model} has no common variables"
@@ -140,7 +140,7 @@ class ModelManager(DataSource):
                     self.append_data(data, f"{var}")
 
         def _add_cycle_variables() -> None:
-            """Add cycle depending variables"""
+            """Add cycle depending variables."""
             wanted_vars = self.model_vars.cycle_var
             if wanted_vars is None:
                 msg = f"Model {self.model} has no cycle variables"
@@ -160,7 +160,7 @@ class ModelManager(DataSource):
         _add_cycle_variables()
 
     def cut_off_extra_levels(self, data: np.ndarray) -> np.ndarray:
-        """Remove unused levels (over 22km) from model data"""
+        """Remove unused levels (over 22km) from model data."""
         try:
             level = self.model_info.level
         except KeyError:
@@ -169,7 +169,7 @@ class ModelManager(DataSource):
         return data[:, :level] if data.ndim > 1 else data[:level]
 
     def _calculate_wind_speed(self) -> np.ndarray:
-        """Real wind from x- and y-components"""
+        """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

@@ -58,7 +58,7 @@ class ObservationManager(DataSource):
             return None
 
     def _generate_product(self) -> None:
-        """Process needed data of observation to a ObservationManager object"""
+        """Process needed data of observation to a ObservationManager object."""
         try:
             if self.obs == "cf":
                 self.append_data(self._generate_cf(), "cf")
@@ -73,7 +73,7 @@ class ObservationManager(DataSource):
             raise
 
     def _generate_cf(self) -> np.ndarray:
-        """Generates cloud fractions using categorize bits and masking conditions"""
+        """Generates cloud fractions using categorize bits and masking conditions."""
         categorize_bits = CategorizeBits(self._file)
         cloud_mask = self._classify_basic_mask(categorize_bits.category_bits)
         return self._mask_cloud_bits(cloud_mask)
@@ -91,7 +91,7 @@ class ObservationManager(DataSource):
 
     @staticmethod
     def _mask_cloud_bits(cloud_mask: np.ndarray) -> np.ndarray:
-        """Creates cloud fraction"""
+        """Creates cloud fraction."""
         for i in [1, 3, 4, 5]:
             cloud_mask[cloud_mask == i] = 1
         for i in [2, 6, 7, 8]:
@@ -99,7 +99,7 @@ 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")
         except RuntimeError:
@@ -122,7 +122,7 @@ class ObservationManager(DataSource):
         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")
@@ -131,21 +131,21 @@ class ObservationManager(DataSource):
         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"""
+        """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:
         """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"""
+        """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/tools.py

@@ -10,7 +10,7 @@ from cloudnetpy.model_evaluation.products.observation_products import Observatio
 
 
 def check_model_file_list(name: str, models: list) -> None:
-    """Check that files in models are from same model and date"""
+    """Check that files in models are from same model and date."""
     for m in models:
         if name not in m:
             logging.error("Invalid model file set")
@@ -35,16 +35,14 @@ def calculate_advection_time(
     wind: ma.MaskedArray,
     sampling: int,
 ) -> np.ndarray:
-    """Calculates time which variable takes to go through the time window
+    """Calculates time which variable takes to go through the time window.
 
-    Notes
+    Notes:
         Wind speed is stronger in upper levels, so advection time is more
         there then lower levels. Effect is small in a mid-latitudes,
         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
@@ -76,7 +74,7 @@ def get_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"""
+    """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):
@@ -90,5 +88,5 @@ def add_date(model_obj: ModelManager, obs_obj: ObservationManager) -> None:
 
 
 def average_column_sum(data: np.ndarray) -> np.ndarray:
-    """Returns average sum of columns which have any data"""
+    """Returns average sum of columns which have any data."""
     return np.nanmean(np.nansum(data, 1) > 0)

cloudnetpy/model_evaluation/statistics/statistical_methods.py

@@ -9,7 +9,7 @@ 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.
@@ -107,7 +107,7 @@ def combine_masked_indices(
     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

cloudnetpy/output.py

@@ -1,4 +1,5 @@
 """Functions for file writing."""
+
 import datetime
 import logging
 from os import PathLike
@@ -140,10 +141,11 @@ def get_l1b_title(instrument: Instrument, location: str) -> str:
 
 
 def get_references(identifier: str | None = None, extra: list | None = None) -> str:
-    """ "Returns references.
+    """Returns references.
 
     Args:
         identifier: Cloudnet file type, e.g., 'iwc'.
+        extra: List of additional references to include
 
     """
     references = "https://doi.org/10.21105/joss.02123"

cloudnetpy/plotting/plot_meta.py

@@ -1,11 +1,11 @@
 """Metadata for plotting module."""
+
 from collections.abc import Sequence
 from typing import NamedTuple
 
 
 class PlotMeta(NamedTuple):
-    """
-    A class representing the metadata for plotting.
+    """A class representing the metadata for plotting.
 
     Attributes:
         cmap: The colormap to be used for the plot.