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

cloudnetpy/instruments/rpg_reader.py

@@ -6,6 +6,7 @@ from numpy import ma
 from numpy.lib import recfunctions as rfn
 from rpgpy import read_rpg
 
+from cloudnetpy.constants import G_TO_KG
 from cloudnetpy.exceptions import ValidTimeStampError
 
 
@@ -108,7 +109,9 @@ class Fmcw94Bin:
 
 
 def _read_from_file(
-    file: BinaryIO, fields: list[tuple[str, str]], count: int | None = None
+    file: BinaryIO,
+    fields: list[tuple[str, str]],
+    count: int | None = None,
 ) -> ma.MaskedArray:
     arr = np.fromfile(file, np.dtype(fields), 1 if count is None else count)
     masked_arr = ma.array(arr)
@@ -118,10 +121,10 @@ def _read_from_file(
 
 
 def _decode_angles(
-    x: np.ndarray, version: Literal[1, 2]
+    x: np.ndarray,
+    version: Literal[1, 2],
 ) -> tuple[np.ndarray, np.ndarray]:
-    """
-    Decode elevation and azimuth angles.
+    """Decode elevation and azimuth angles.
 
     >>> _decode_angles(np.array([1267438.5]), version=1)
     (array([138.5]), array([267.4]))
@@ -131,7 +134,6 @@ def _decode_angles(
     Based on `interpret_angle` from mwr_raw2l1 licensed under BSD 3-Clause:
     https://github.com/MeteoSwiss/mwr_raw2l1/blob/0738490d22f77138cdf9329bf102f319c78be584/mwr_raw2l1/readers/reader_rpg_helpers.py#L30
     """
-
     if version == 1:
         # Description in the manual is quite unclear so here's an improved one:
         # Ang=sign(El)*(|El|+1000*Az), -90°<=El<100°, 0°<=Az<360°. If El>=100°
@@ -153,9 +155,8 @@ def _decode_angles(
         ele = np.sign(x) * (np.abs(x) // 1e5) / 100
         azi = (np.abs(x) - np.abs(ele) * 1e7) / 100
     else:
-        raise NotImplementedError(
-            f"Known versions for angle encoding are 1 and 2, but received {version}"
-        )
+        msg = f"Known versions for angle encoding are 1 and 2, but received {version}"
+        raise NotImplementedError(msg)
 
     return ele, azi
 
@@ -163,7 +164,8 @@ def _decode_angles(
 class HatproBin:
     """HATPRO binary file reader. Byte order is assumed to be little endian.
 
-    References:
+    References
+    ----------
         Radiometer Physics (2014): Instrument Operation and Software Guide
         Operation Principles and Software Description for RPG standard single
         polarization radiometers (G5 series).
@@ -188,30 +190,33 @@ class HatproBin:
         self._remove_duplicate_timestamps()
         self._add_zenith_angle()
 
-    def screen_bad_profiles(self):
+    def screen_bad_profiles(self) -> None:
         is_bad = self.data["_quality_flag"] & 0b110 == self.QUALITY_LOW << 1
         n_bad = np.count_nonzero(is_bad)
         if n_bad == len(is_bad):
-            raise ValidTimeStampError("All data are low quality")
+            msg = "All data are low quality"
+            raise ValidTimeStampError(msg)
         if n_bad:
             percentage = round(100 * n_bad / len(is_bad))
             logging.info(
-                f"Screening {percentage}% ({n_bad}/{len(is_bad)})"
-                " data points with low quality"
+                "Screening %s %% (%s/%s) data points with low quality",
+                percentage,
+                n_bad,
+                len(is_bad),
             )
         self.data[self.variable][is_bad] = ma.masked
 
-    def _remove_duplicate_timestamps(self):
+    def _remove_duplicate_timestamps(self) -> None:
         _, ind = np.unique(self.data["time"], return_index=True)
         self.data = self.data[ind]
 
-    def _read_header(self, file: BinaryIO):
-        raise NotImplementedError()
+    def _read_header(self, file: BinaryIO) -> None:
+        raise NotImplementedError
 
-    def _read_data(self, file: BinaryIO):
-        raise NotImplementedError()
+    def _read_data(self, file: BinaryIO) -> None:
+        raise NotImplementedError
 
-    def _add_zenith_angle(self):
+    def _add_zenith_angle(self) -> None:
         ele, _azi = _decode_angles(self.data["_instrument_angles"], self.version)
         self.data = rfn.append_fields(self.data, "zenith_angle", 90 - ele)
 
@@ -221,7 +226,7 @@ class HatproBinLwp(HatproBin):
 
     variable = "lwp"
 
-    def _read_header(self, file):
+    def _read_header(self, file) -> None:
         self.header = _read_from_file(
             file,
             [
@@ -238,9 +243,10 @@ class HatproBinLwp(HatproBin):
         elif self.header["file_code"] == 934501000:
             self.version = 2
         else:
-            raise ValueError(f'Unknown HATPRO version. {self.header["file_code"]}')
+            msg = f'Unknown HATPRO version. {self.header["file_code"]}'
+            raise ValueError(msg)
 
-    def _read_data(self, file):
+    def _read_data(self, file) -> None:
         self.data = _read_from_file(
             file,
             [
@@ -251,7 +257,7 @@ class HatproBinLwp(HatproBin):
             ],
             self.header["_n_samples"],
         )
-        self.data["lwp"] *= 1e-3  # Convert from g/m^2 to kg/m^2
+        self.data["lwp"] *= G_TO_KG
 
 
 class HatproBinIwv(HatproBin):
@@ -259,7 +265,7 @@ class HatproBinIwv(HatproBin):
 
     variable = "iwv"
 
-    def _read_header(self, file):
+    def _read_header(self, file) -> None:
         self.header = _read_from_file(
             file,
             [
@@ -276,9 +282,10 @@ class HatproBinIwv(HatproBin):
         elif self.header["file_code"] == 594811000:
             self.version = 2
         else:
-            raise ValueError(f'Unknown HATPRO version. {self.header["file_code"]}')
+            msg = f'Unknown HATPRO version. {self.header["file_code"]}'
+            raise ValueError(msg)
 
-    def _read_data(self, file):
+    def _read_data(self, file) -> None:
         self.data = _read_from_file(
             file,
             [
@@ -310,16 +317,18 @@ class HatproBinCombined:
                 _combine_values(arr["zenith_angle1"], arr["zenith_angle2"]),
             )
             # Workaround because rfn.drop_fields seems to incorrectly drop mask...
-            # arr = rfn.drop_fields(arr, ["zenith_angle1", "zenith_angle2"])
             arr = rfn.rename_fields(
-                arr, {"zenith_angle1": "_tmp1", "zenith_angle2": "_tmp2"}
+                arr,
+                {"zenith_angle1": "_tmp1", "zenith_angle2": "_tmp2"},
             )
         else:
-            raise NotImplementedError("Only implemented up to 2 files")
+            msg = "Only implemented up to 2 files"
+            raise NotImplementedError(msg)
         self.data = {field: arr[field] for field in arr.dtype.fields}
 
 
 def _combine_values(arr1: ma.MaskedArray, arr2: ma.MaskedArray) -> ma.MaskedArray:
     if not ma.allequal(arr1, arr2):
-        raise ValueError("Inconsistent values")
+        msg = "Inconsistent values"
+        raise ValueError(msg)
     return ma.where(~arr1.mask, arr1, arr2)

cloudnetpy/instruments/vaisala.py

@@ -1,23 +1,26 @@
 """Module with classes for Vaisala ceilometers."""
+import itertools
 import logging
 
 import numpy as np
 
 from cloudnetpy import utils
+from cloudnetpy.constants import SEC_IN_HOUR, SEC_IN_MINUTE
 from cloudnetpy.exceptions import ValidTimeStampError
 from cloudnetpy.instruments import instruments
 from cloudnetpy.instruments.ceilometer import Ceilometer, NoiseParam
 
 M2KM = 0.001
-SECONDS_IN_MINUTE = 60
-SECONDS_IN_HOUR = 3600
 
 
 class VaisalaCeilo(Ceilometer):
     """Base class for Vaisala ceilometers."""
 
     def __init__(
-        self, full_path: str, site_meta: dict, expected_date: str | None = None
+        self,
+        full_path: str,
+        site_meta: dict,
+        expected_date: str | None = None,
     ):
         super().__init__(self.noise_param)
         self.full_path = full_path
@@ -87,7 +90,8 @@ class VaisalaCeilo(Ceilometer):
             for i, line in enumerate(data[timestamp_line_number:]):
                 if utils.is_empty_line(line):
                     return i
-            raise RuntimeError("Can not parse number of data lines")
+            msg = "Can not parse number of data lines"
+            raise RuntimeError(msg)
 
         def _parse_data_lines(data: list, starting_indices: list) -> list:
             return [
@@ -103,20 +107,23 @@ class VaisalaCeilo(Ceilometer):
         timestamp_line_numbers = _find_timestamp_line_numbers(valid_lines)
         if self.expected_date is not None:
             timestamp_line_numbers = _find_correct_dates(
-                valid_lines, timestamp_line_numbers
+                valid_lines,
+                timestamp_line_numbers,
             )
             if not timestamp_line_numbers:
                 raise ValidTimeStampError
         number_of_data_lines = _find_number_of_data_lines(
-            valid_lines, timestamp_line_numbers[0]
+            valid_lines,
+            timestamp_line_numbers[0],
         )
-        data_lines = _parse_data_lines(valid_lines, timestamp_line_numbers)
-        return data_lines
+        return _parse_data_lines(valid_lines, timestamp_line_numbers)
 
     @staticmethod
     def _get_message_number(header_line_1: dict) -> int:
         msg_no = header_line_1["message_number"]
-        assert len(np.unique(msg_no)) == 1, "Error: inconsistent message numbers."
+        if len(np.unique(msg_no)) != 1:
+            msg = "Error: inconsistent message numbers."
+            raise RuntimeError(msg)
         return int(msg_no[0])
 
     @staticmethod
@@ -134,8 +141,7 @@ class VaisalaCeilo(Ceilometer):
     def _handle_metadata(cls, header: list) -> dict:
         meta = cls._concatenate_meta(header)
         meta = cls._remove_meta_duplicates(meta)
-        meta = cls._convert_meta_strings(meta)
-        return meta
+        return cls._convert_meta_strings(meta)
 
     @staticmethod
     def _concatenate_meta(header: list) -> dict:
@@ -196,10 +202,7 @@ class VaisalaCeilo(Ceilometer):
             "message_number",
             "message_subclass",
         )
-        if self._is_ct25k():
-            indices = [1, 3, 4, 6, 7, 8]
-        else:
-            indices = [1, 3, 4, 7, 8, 9]
+        indices = [1, 3, 4, 6, 7, 8] if self._is_ct25k() else [1, 3, 4, 7, 8, 9]
         values = [split_string(line, indices) for line in lines]
         return values_to_dict(fields, values)
 
@@ -222,7 +225,10 @@ class ClCeilo(VaisalaCeilo):
     noise_param = NoiseParam(noise_min=3.1e-8, noise_smooth_min=1.1e-8)
 
     def __init__(
-        self, full_path: str, site_meta: dict, expected_date: str | None = None
+        self,
+        full_path: str,
+        site_meta: dict,
+        expected_date: str | None = None,
     ):
         super().__init__(full_path, site_meta, expected_date)
         self._hex_conversion_params = (5, 524288, 1048576)
@@ -241,7 +247,7 @@ class ClCeilo(VaisalaCeilo):
         self._store_ceilometer_info()
         self._sort_time()
 
-    def _sort_time(self):
+    def _sort_time(self) -> None:
         """Sorts timestamps and removes duplicates."""
         time = np.copy(self.data["time"][:])
         ind_sorted = np.argsort(time)
@@ -258,7 +264,7 @@ class ClCeilo(VaisalaCeilo):
             if array.ndim == 2 and array.shape[0] == n_time:
                 self.data[key] = self.data[key][ind_valid, :]
 
-    def _store_ceilometer_info(self):
+    def _store_ceilometer_info(self) -> None:
         n_gates = self.data["beta_raw"].shape[1]
         if n_gates < 1540:
             self.instrument = instruments.CL31
@@ -267,7 +273,8 @@ class ClCeilo(VaisalaCeilo):
 
     def _read_header_line_3(self, lines: list) -> dict:
         if self._message_number != 2:
-            raise RuntimeError("Unsupported message number.")
+            msg = f"Unsupported message number: {self._message_number}"
+            raise RuntimeError(msg)
         keys = ("cloud_detection_status", "cloud_amount_data")
         values = [[line[0:3], line[3:].strip()] for line in lines]
         return values_to_dict(keys, values)
@@ -293,7 +300,8 @@ class ClCeilo(VaisalaCeilo):
 class Ct25k(VaisalaCeilo):
     """Class for Vaisala CT25k ceilometer.
 
-    References:
+    References
+    ----------
         https://www.manualslib.com/manual/1414094/Vaisala-Ct25k.html
 
     """
@@ -334,7 +342,8 @@ class Ct25k(VaisalaCeilo):
 
     def _read_header_line_3(self, lines: list) -> dict:
         if self._message_number in (1, 3, 6):
-            raise RuntimeError(f"Unsupported message number: {self._message_number}")
+            msg = f"Unsupported message number: {self._message_number}"
+            raise RuntimeError(msg)
         keys = (
             "measurement_mode",
             "laser_energy",
@@ -347,31 +356,34 @@ class Ct25k(VaisalaCeilo):
             "backscatter_sum",
         )
         values = [line.split() for line in lines]
-        keys_out = ("scale",) + keys if len(values[0]) == 10 else keys
+        keys_out = ("scale", *keys) if len(values[0]) == 10 else keys
         return values_to_dict(keys_out, values)
 
 
 def split_string(string: str, indices: list) -> list:
     """Splits string between indices.
 
-    Notes:
+    Notes
+    -----
         It is possible to skip characters from the beginning and end of the
         string but not from the middle.
 
-    Examples:
+    Examples
+    --------
         >>> s = 'abcde'
         >>> indices = [1, 2, 4]
         >>> split_string(s, indices)
         ['b', 'cd']
 
     """
-    return [string[n:m] for n, m in zip(indices[:-1], indices[1:])]
+    return [string[n:m] for n, m in itertools.pairwise(indices)]
 
 
 def values_to_dict(keys: tuple, values: list) -> dict:
     """Converts list elements to dictionary.
 
-    Examples:
+    Examples
+    --------
         >>> keys = ('a', 'b')
         >>> values = [[1, 2], [1, 2], [1, 2], [1, 2]]
         >>> values_to_dict(keys, values)
@@ -387,4 +399,4 @@ def values_to_dict(keys: tuple, values: list) -> dict:
 def time_to_fraction_hour(time: str) -> float:
     """Returns time (hh:mm:ss) as fraction hour"""
     hour, minute, sec = time.split(":")
-    return int(hour) + (int(minute) * SECONDS_IN_MINUTE + int(sec)) / SECONDS_IN_HOUR
+    return int(hour) + (int(minute) * SEC_IN_MINUTE + int(sec)) / SEC_IN_HOUR

cloudnetpy/instruments/weather_station.py

@@ -22,6 +22,7 @@ def ws2nc(
     """Converts weather-station data into Cloudnet Level 1b netCDF file.
 
     Args:
+    ----
         weather_station_file: Filename of weather-station ASCII file.
         output_file: Output filename.
         site_meta: Dictionary containing information about the site. Required key
@@ -30,13 +31,14 @@ def ws2nc(
         date: Expected date of the measurements as YYYY-MM-DD.
 
     Returns:
+    -------
         UUID of the generated file.
 
     Raises:
+    ------
         WeatherStationDataError : Unable to read the file.
         ValidTimeStampError: No valid timestamps found.
     """
-
     try:
         ws = WS(weather_station_file, site_meta)
         if date is not None:
@@ -50,8 +52,7 @@ def ws2nc(
         output.update_attributes(ws.data, attributes)
     except ValueError as err:
         raise WeatherStationDataError from err
-    uuid = output.save_level1b(ws, output_file, uuid)
-    return uuid
+    return output.save_level1b(ws, output_file, uuid)
 
 
 class WS(CloudnetInstrument):
@@ -63,14 +64,17 @@ class WS(CloudnetInstrument):
         self.instrument = instruments.GENERIC_WEATHER_STATION
         self._data = self._read_data()
 
-    def _read_data(self):
+    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")
+                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)
@@ -93,16 +97,16 @@ class WS(CloudnetInstrument):
         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):
+        for title, identifier in zip(column_titles, expected_identifiers, strict=True):
             if identifier not in title:
                 raise ValueError(error_msg)
         return {"timestamps": timestamps, "values": values}
 
-    def convert_time(self):
+    def convert_time(self) -> None:
         decimal_hours = datetime2decimal_hours(self._data["timestamps"])
         self.data["time"] = CloudnetArray(decimal_hours, "time")
 
-    def screen_timestamps(self, date: str):
+    def screen_timestamps(self, date: str) -> None:
         dates = [str(d.date()) for d in self._data["timestamps"]]
         valid_ind = [ind for ind, d in enumerate(dates) if d == date]
         if not valid_ind:
@@ -112,7 +116,7 @@ class WS(CloudnetInstrument):
                 x for ind, x in enumerate(self._data[key]) if ind in valid_ind
             ]
 
-    def add_date(self):
+    def add_date(self) -> None:
         first_date = self._data["timestamps"][0].date()
         self.date = [
             str(first_date.year),
@@ -120,7 +124,7 @@ class WS(CloudnetInstrument):
             str(first_date.day).zfill(2),
         ]
 
-    def add_data(self):
+    def add_data(self) -> None:
         keys = (
             "wind_speed",
             "wind_direction",
@@ -135,7 +139,7 @@ class WS(CloudnetInstrument):
             array_masked = ma.masked_invalid(array)
             self.data[key] = CloudnetArray(array_masked, key)
 
-    def convert_units(self):
+    def convert_units(self) -> None:
         temperature_kelvins = atmos_utils.c2k(self.data["air_temperature"][:])
         self.data["air_temperature"].data = temperature_kelvins
         self.data["relative_humidity"].data = self.data["relative_humidity"][:] / 100

cloudnetpy/metadata.py

@@ -46,7 +46,9 @@ COMMON_ATTRIBUTES = {
         standard_name="longitude",
     ),
     "altitude": MetaData(
-        long_name="Altitude of site", standard_name="altitude", units="m"
+        long_name="Altitude of site",
+        standard_name="altitude",
+        units="m",
     ),
     "Zh": MetaData(
         long_name="Radar reflectivity factor",

cloudnetpy/model_evaluation/file_handler.py

@@ -14,12 +14,13 @@ from .metadata import (
 from .products.model_products import ModelManager
 
 
-def update_attributes(model_downsample_variables: dict, attributes: dict):
+def update_attributes(model_downsample_variables: dict, attributes: dict) -> None:
     """Overrides existing Cloudnet-ME Array-attributes.
         Overrides existing attributes using hard-coded values.
         New attributes are added.
 
     Args:
+    ----
         model_downsample_variables (dict): Array instances.
         attributes (dict): Product-specific attributes.
     """
@@ -32,11 +33,11 @@ def update_attributes(model_downsample_variables: dict, attributes: dict):
             model_downsample_variables[key].set_attributes(MODEL_ATTRIBUTES[key])
         elif "_".join(key_parts[0:-1]) in REGRID_PRODUCT_ATTRIBUTES:
             model_downsample_variables[key].set_attributes(
-                REGRID_PRODUCT_ATTRIBUTES["_".join(key_parts[0:-1])]
+                REGRID_PRODUCT_ATTRIBUTES["_".join(key_parts[0:-1])],
             )
         elif "_".join(key_parts[0:-2]) in REGRID_PRODUCT_ATTRIBUTES:
             model_downsample_variables[key].set_attributes(
-                REGRID_PRODUCT_ATTRIBUTES["_".join(key_parts[0:-2])]
+                REGRID_PRODUCT_ATTRIBUTES["_".join(key_parts[0:-2])],
             )
         elif (
             "_".join(key_parts[1:]) in MODEL_L3_ATTRIBUTES
@@ -44,19 +45,19 @@ def update_attributes(model_downsample_variables: dict, attributes: dict):
         ):
             try:
                 model_downsample_variables[key].set_attributes(
-                    MODEL_L3_ATTRIBUTES["_".join(key_parts[1:])]
+                    MODEL_L3_ATTRIBUTES["_".join(key_parts[1:])],
                 )
             except KeyError:
                 model_downsample_variables[key].set_attributes(
-                    MODEL_L3_ATTRIBUTES["_".join(key_parts[2:])]
+                    MODEL_L3_ATTRIBUTES["_".join(key_parts[2:])],
                 )
         elif "_".join(key_parts[1:]) in CYCLE_ATTRIBUTES:
             model_downsample_variables[key].set_attributes(
-                CYCLE_ATTRIBUTES["_".join(key_parts[1:])]
+                CYCLE_ATTRIBUTES["_".join(key_parts[1:])],
             )
         elif "_".join(key_parts[2:]) in CYCLE_ATTRIBUTES:
             model_downsample_variables[key].set_attributes(
-                CYCLE_ATTRIBUTES["_".join(key_parts[2:])]
+                CYCLE_ATTRIBUTES["_".join(key_parts[2:])],
             )
 
 
@@ -66,10 +67,11 @@ def save_downsampled_file(
     objects: tuple,
     files: tuple,
     uuid: str | None,
-):
+) -> str:
     """Saves a standard downsampled day product file.
 
     Args:
+    ----
         id_mark (str): File identifier, format "(product name)_(model name)"
         file_name (str): Name of the output file to be generated
         objects (tuple): Include two objects: The :class:'ModelManager' and
@@ -92,25 +94,26 @@ def save_downsampled_file(
     )
     _add_source(root_group, objects, files)
     output.copy_global(obj.dataset, root_group, ("location", "day", "month", "year"))
-    try:
-        obj.dataset.day
-    except AttributeError:
+    if not hasattr(obj.dataset, "day"):
         root_group.year, root_group.month, root_group.day = obj.date
     output.merge_history(root_group, id_mark, {"l3": obj})
     root_group.close()
+    if not isinstance(uuid, str):
+        msg = "UUID is not a string."
+        raise TypeError(msg)
     return uuid
 
 
-def add_var2ncfile(obj: ModelManager, file_name: str):
+def add_var2ncfile(obj: ModelManager, file_name: str) -> None:
     nc_file = netCDF4.Dataset(file_name, "r+", format="NETCDF4_CLASSIC")
     _write_vars2nc(nc_file, obj.data)
     nc_file.close()
 
 
-def _write_vars2nc(rootgrp: netCDF4.Dataset, cloudnet_variables: dict):
+def _write_vars2nc(rootgrp: netCDF4.Dataset, cloudnet_variables: dict) -> None:
     """Iterates over Cloudnet-ME instances and write to given rootgrp."""
 
-    def _get_dimensions(array):
+    def _get_dimensions(array) -> tuple:
         """Finds correct dimensions for a variable."""
         if utils.isscalar(array):
             return ()
@@ -118,8 +121,8 @@ def _write_vars2nc(rootgrp: netCDF4.Dataset, cloudnet_variables: dict):
         file_dims = rootgrp.dimensions
         array_dims = array.shape
         for length in array_dims:
-            dim = [key for key in file_dims.keys() if file_dims[key].size == length][0]
-            variable_size = variable_size + (dim,)
+            dim = [key for key in file_dims if file_dims[key].size == length][0]  # noqa: RUF015
+            variable_size = (*variable_size, dim)
         return variable_size
 
     for key in cloudnet_variables:
@@ -127,7 +130,10 @@ def _write_vars2nc(rootgrp: netCDF4.Dataset, cloudnet_variables: dict):
         size = _get_dimensions(obj.data)
         try:
             nc_variable = rootgrp.createVariable(
-                obj.name, obj.data_type, size, zlib=True
+                obj.name,
+                obj.data_type,
+                size,
+                zlib=True,
             )
             nc_variable[:] = obj.data
             for attr in obj.fetch_attributes():
@@ -136,11 +142,11 @@ def _write_vars2nc(rootgrp: netCDF4.Dataset, cloudnet_variables: dict):
             continue
 
 
-def _augment_global_attributes(root_group: netCDF4.Dataset):
+def _augment_global_attributes(root_group: netCDF4.Dataset) -> None:
     root_group.Conventions = "CF-1.8"
 
 
-def _add_source(root_ground: netCDF4.Dataset, objects: tuple, files: tuple):
+def _add_source(root_ground: netCDF4.Dataset, objects: tuple, files: tuple) -> None:
     """Generates source info for multiple files"""
     model, obs = objects
     model_files, obs_file = files
@@ -157,14 +163,18 @@ def _add_source(root_ground: netCDF4.Dataset, objects: tuple, files: tuple):
 
 def add_time_attribute(date: datetime) -> dict:
     """ "Adds time attribute with correct units.
+
     Args:
+    ----
         attributes: Attributes of variables.
         date: Date as Y M D 0 0 0.
+
     Returns:
+    -------
         dict: Same attributes with 'time' attribute added.
     """
     return {
         "time": MODEL_ATTRIBUTES["time"]._replace(
-            units=f"hours since {date:%Y-%m-%d} 00:00:00 +00:00"
-        )
+            units=f"hours since {date:%Y-%m-%d} 00:00:00 +00:00",
+        ),
     }

cloudnetpy/model_evaluation/metadata.py

@@ -51,7 +51,9 @@ CYCLE_ATTRIBUTES = {
     "pressure": MetaData(long_name="Pressure", units="Pa"),
     "temperature": MetaData(long_name="Temperature", units="K"),
     "uwind": MetaData(
-        long_name="Zonal wind", units="m s-1", standard_name="eastward_wind"
+        long_name="Zonal wind",
+        units="m s-1",
+        standard_name="eastward_wind",
     ),
     "vwind": MetaData(
         long_name="Meridional wind",

cloudnetpy/model_evaluation/model_metadata.py

@@ -30,7 +30,7 @@ MODELS = {
     ),
     "harmonie": ModelMetaData(
         model_name="HARMONIE-AROME",
-        long_name="the HIRLAM–ALADIN Research on Mesoscale Operational NWP in Euromed",
+        long_name="the HIRLAM–ALADIN Research on Mesoscale Operational NWP in Euromed",  # noqa: RUF001
         level=65,
         cycle="6-11",
     ),