cloudnetpy 1.80.8__py3-none-any.whl → 1.81.1__py3-none-any.whl

cloudnetpy/instruments/rain_e_h3.py

@@ -1,6 +1,7 @@
 import csv
 import datetime
 from os import PathLike
+from uuid import UUID
 
 import numpy as np
 
@@ -8,15 +9,16 @@ from cloudnetpy import output
 from cloudnetpy.exceptions import ValidTimeStampError
 from cloudnetpy.instruments import instruments
 from cloudnetpy.instruments.cloudnet_instrument import CSVFile
+from cloudnetpy.utils import get_uuid
 
 
 def rain_e_h32nc(
     input_file: str | PathLike,
-    output_file: str,
+    output_file: str | PathLike,
     site_meta: dict,
-    uuid: str | None = None,
+    uuid: str | UUID | None = None,
     date: str | datetime.date | None = None,
-):
+) -> UUID:
     """Converts rain_e_h3 rain-gauge into Cloudnet Level 1b netCDF file.
 
     Args:
@@ -36,6 +38,7 @@ def rain_e_h32nc(
     rain = RainEH3(site_meta)
     if isinstance(date, str):
         date = datetime.date.fromisoformat(date)
+    uuid = get_uuid(uuid)
     rain.parse_input_file(input_file, date)
     rain.add_data()
     rain.add_date()
@@ -46,11 +49,12 @@ def rain_e_h32nc(
     rain.remove_duplicate_timestamps()
     attributes = output.add_time_attribute({}, rain.date)
     output.update_attributes(rain.data, attributes)
-    return output.save_level1b(rain, output_file, uuid)
+    output.save_level1b(rain, output_file, uuid)
+    return uuid
 
 
 class RainEH3(CSVFile):
-    def __init__(self, site_meta: dict):
+    def __init__(self, site_meta: dict) -> None:
         super().__init__(site_meta)
         self.instrument = instruments.RAIN_E_H3
         self._data = {

cloudnetpy/instruments/rpg.py

@@ -1,10 +1,14 @@
 """This module contains RPG Cloud Radar related functions."""
 
+import datetime
 import logging
 import math
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
+from os import PathLike
+from uuid import UUID
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from rpgpy import RPGFileError
 
@@ -20,12 +24,12 @@ from cloudnetpy.metadata import MetaData
 
 
 def rpg2nc(
-    path_to_l1_files: str,
-    output_file: str,
+    path_to_l1_files: str | PathLike,
+    output_file: str | PathLike,
     site_meta: dict,
-    uuid: str | None = None,
-    date: str | None = None,
-) -> tuple[str, list]:
+    uuid: str | UUID | None = None,
+    date: str | datetime.date | None = None,
+) -> tuple[UUID, list[str]]:
     """Converts RPG-FMCW-94 cloud radar data into Cloudnet Level 1b netCDF file.
 
     This function reads one day of RPG Level 1 cloud radar binary files,
@@ -58,11 +62,14 @@ def rpg2nc(
         >>> rpg2nc('/path/to/files/', 'test.nc', site_meta)
 
     """
+    if isinstance(date, str):
+        date = datetime.date.fromisoformat(date)
+    uuid = utils.get_uuid(uuid)
     l1_files = utils.get_sorted_filenames(path_to_l1_files, ".LV1")
     fmcw94_objects, valid_files = _get_fmcw94_objects(l1_files, date)
     one_day_of_data = create_one_day_data_record(fmcw94_objects)
     if not valid_files:
-        return "", []
+        return uuid, []
     print_info(one_day_of_data)
     fmcw = Fmcw(one_day_of_data, site_meta)
     fmcw.convert_time_to_fraction_hour()
@@ -78,7 +85,7 @@ def rpg2nc(
     fmcw.add_height()
     attributes = output.add_time_attribute(RPG_ATTRIBUTES, fmcw.date)
     output.update_attributes(fmcw.data, attributes)
-    uuid = output.save_level1b(fmcw, output_file, uuid)
+    output.save_level1b(fmcw, output_file, uuid)
     return uuid, valid_files
 
 
@@ -113,7 +120,7 @@ def _stack_rpg_data(rpg_objects: RpgObjects) -> tuple[dict, dict]:
 
     """
 
-    def _stack(source, target, fun) -> None:
+    def _stack(source: dict, target: dict, fun: Callable) -> None:
         for name, value in source.items():
             if not name.startswith("_"):
                 target[name] = fun((target[name], value)) if name in target else value
@@ -168,7 +175,9 @@ def _mask_invalid_data(data_in: dict) -> dict:
     return data
 
 
-def _get_fmcw94_objects(files: list, expected_date: str | None) -> tuple[list, list]:
+def _get_fmcw94_objects(
+    files: list[str], expected_date: datetime.date | None
+) -> tuple[list[Fmcw94Bin], list[str]]:
     """Creates a list of Rpg() objects from the file names."""
     objects = []
     valid_files = []
@@ -211,10 +220,10 @@ def _remove_files_with_bad_height(objects: list, files: list) -> tuple[list, lis
     return objects, files
 
 
-def _validate_date(obj, expected_date: str) -> None:
+def _validate_date(obj: Fmcw94Bin, expected_date: datetime.date) -> None:
     for t in obj.data["time"][:]:
-        date_str = "-".join(utils.seconds2date(t)[:3])
-        if date_str != expected_date:
+        date = utils.seconds2date(t).date()
+        if date != expected_date:
             msg = "Ignoring a file (time stamps not what expected)"
             raise ValueError(msg)
 
@@ -222,7 +231,7 @@ def _validate_date(obj, expected_date: str) -> None:
 class Rpg(CloudnetInstrument):
     """Base class for RPG FMCW-94 cloud radar and HATPRO mwr."""
 
-    def __init__(self, raw_data: dict, site_meta: dict):
+    def __init__(self, raw_data: dict, site_meta: dict) -> None:
         super().__init__()
         self.raw_data = raw_data
         self.site_meta = site_meta
@@ -242,11 +251,11 @@ class Rpg(CloudnetInstrument):
             data_type=data_type,
         )
 
-    def _get_date(self) -> list:
+    def _get_date(self) -> datetime.date:
         time_first = self.raw_data["time"][0]
         time_last = self.raw_data["time"][-1]
-        date_first = utils.seconds2date(time_first)[:3]
-        date_last = utils.seconds2date(time_last)[:3]
+        date_first = utils.seconds2date(time_first).date()
+        date_last = utils.seconds2date(time_last).date()
         if date_first != date_last:
             logging.warning("Measurements from different days")
         return date_first
@@ -261,7 +270,7 @@ class Rpg(CloudnetInstrument):
 class Fmcw(Rpg):
     """Class for RPG cloud radars."""
 
-    def __init__(self, raw_data: dict, site_properties: dict):
+    def __init__(self, raw_data: dict, site_properties: dict) -> None:
         super().__init__(raw_data, site_properties)
         self.instrument = self._get_instrument(raw_data)
 
@@ -313,7 +322,7 @@ class Fmcw(Rpg):
         self.data["wind_speed"].data *= KM_H_TO_M_S
 
     @staticmethod
-    def _get_instrument(data: dict):
+    def _get_instrument(data: dict) -> Instrument:
         frequency = data["radar_frequency"]
         if math.isclose(frequency, 35, abs_tol=0.1):
             return instruments.FMCW35
@@ -326,12 +335,14 @@ class Fmcw(Rpg):
 class Hatpro(Rpg):
     """Class for RPG HATPRO mwr."""
 
-    def __init__(self, raw_data: dict, site_properties: dict, instrument: Instrument):
+    def __init__(
+        self, raw_data: dict, site_properties: dict, instrument: Instrument
+    ) -> None:
         super().__init__(raw_data, site_properties)
         self.instrument = instrument
 
 
-def _filter_zenith_angle(zenith: ma.MaskedArray) -> np.ndarray:
+def _filter_zenith_angle(zenith: ma.MaskedArray) -> npt.NDArray:
     """Returns indices of profiles with stable zenith angle close to 0 deg."""
     zenith = ma.array(zenith)
     if zenith.mask.all():

cloudnetpy/instruments/rpg_reader.py

@@ -1,7 +1,10 @@
 import logging
+from os import PathLike
+from pathlib import Path
 from typing import BinaryIO, Literal
 
 import numpy as np
+import numpy.typing as npt
 from numpy import ma
 from numpy.lib import recfunctions as rfn
 from rpgpy import read_rpg
@@ -13,7 +16,7 @@ from cloudnetpy.exceptions import ValidTimeStampError
 class Fmcw94Bin:
     """RPG Cloud Radar Level 1 data reader."""
 
-    def __init__(self, filename):
+    def __init__(self, filename: str | PathLike) -> None:
         self.filename = filename
         self.header, self.data = read_rpg(filename)
 
@@ -101,7 +104,7 @@ class Fmcw94Bin:
         self.replace_keys(self.data, data_keymap)
 
     @staticmethod
-    def replace_keys(d: dict, keymap: dict):
+    def replace_keys(d: dict, keymap: dict) -> None:
         for key in d.copy():
             if key in keymap:
                 new_key = keymap[key]
@@ -121,9 +124,9 @@ def _read_from_file(
 
 
 def _decode_angles(
-    x: np.ndarray,
+    x: npt.NDArray,
     version: Literal[1, 2],
-) -> tuple[np.ndarray, np.ndarray]:
+) -> tuple[npt.NDArray, npt.NDArray]:
     """Decode elevation and azimuth angles.
 
     >>> _decode_angles(np.array([1267438.5]), version=1)
@@ -181,7 +184,7 @@ class HatproBin:
     QUALITY_MEDIUM = 2
     QUALITY_LOW = 3
 
-    def __init__(self, filename):
+    def __init__(self, filename: Path) -> None:
         self.filename = filename
         with open(self.filename, "rb") as file:
             self._read_header(file)
@@ -225,7 +228,7 @@ class HatproBinLwp(HatproBin):
 
     variable = "lwp"
 
-    def _read_header(self, file) -> None:
+    def _read_header(self, file: BinaryIO) -> None:
         self.header = _read_from_file(
             file,
             [
@@ -245,7 +248,7 @@ class HatproBinLwp(HatproBin):
             msg = f"Unknown HATPRO version. {self.header['file_code']}"
             raise ValueError(msg)
 
-    def _read_data(self, file) -> None:
+    def _read_data(self, file: BinaryIO) -> None:
         self.data = _read_from_file(
             file,
             [
@@ -264,7 +267,7 @@ class HatproBinIwv(HatproBin):
 
     variable = "iwv"
 
-    def _read_header(self, file) -> None:
+    def _read_header(self, file: BinaryIO) -> None:
         self.header = _read_from_file(
             file,
             [
@@ -284,7 +287,7 @@ class HatproBinIwv(HatproBin):
             msg = f"Unknown HATPRO version. {self.header['file_code']}"
             raise ValueError(msg)
 
-    def _read_data(self, file) -> None:
+    def _read_data(self, file: BinaryIO) -> None:
         self.data = _read_from_file(
             file,
             [
@@ -300,10 +303,10 @@ class HatproBinIwv(HatproBin):
 class HatproBinCombined:
     """Combine HATPRO objects that share values of the given dimensions."""
 
-    header: dict[str, np.ndarray]
-    data: dict[str, np.ndarray]
+    header: dict[str, npt.NDArray]
+    data: dict[str, npt.NDArray]
 
-    def __init__(self, files: list[HatproBin]):
+    def __init__(self, files: list[HatproBin]) -> None:
         self.header = {}
         if len(files) == 1:
             arr = files[0].data

cloudnetpy/instruments/vaisala.py

@@ -2,6 +2,7 @@
 
 import datetime
 from collections.abc import Callable
+from os import PathLike
 
 import ceilopyter.version
 import numpy as np
@@ -19,20 +20,15 @@ class VaisalaCeilo(Ceilometer):
     def __init__(
         self,
         reader: Callable,
-        full_path: str,
+        full_path: str | PathLike,
         site_meta: dict,
-        expected_date: str | None = None,
-    ):
+        expected_date: datetime.date | None = None,
+    ) -> None:
         super().__init__(self.noise_param)
         self.reader = reader
         self.full_path = full_path
         self.site_meta = site_meta
         self.expected_date = expected_date
-        self.sane_date = (
-            datetime.date.fromisoformat(self.expected_date)
-            if self.expected_date
-            else None
-        )
         self.software = {"ceilopyter": ceilopyter.version.__version__}
 
     def read_ceilometer_file(self, calibration_factor: float | None = None) -> None:
@@ -51,23 +47,21 @@ class VaisalaCeilo(Ceilometer):
         self.convert_to_fraction_hour()
         self._store_ceilometer_info()
 
-    def sort_time(self):
+    def sort_time(self) -> None:
         """Sorts timestamps and removes duplicates."""
         time = self.data["time"]
         _time, ind = np.unique(time, return_index=True)
         self._screen_time_indices(ind)
 
-    def screen_date(self):
+    def screen_date(self) -> None:
         time = self.data["time"]
-        if self.sane_date is None:
-            self.sane_date = time[0].date()
-            self.expected_date = self.sane_date.isoformat()
-        is_valid = np.array([t.date() == self.sane_date for t in time])
+        self.date = time[0].date() if self.expected_date is None else self.expected_date
+        is_valid = np.array([t.date() == self.date for t in time])
         self._screen_time_indices(is_valid)
 
     def _screen_time_indices(
         self, valid_indices: npt.NDArray[np.intp] | npt.NDArray[np.bool]
-    ):
+    ) -> None:
         time = self.data["time"]
         n_time = len(time)
         if len(valid_indices) == 0 or (
@@ -79,14 +73,13 @@ class VaisalaCeilo(Ceilometer):
             if hasattr(array, "shape") and array.shape[:1] == (n_time,):
                 self.data[key] = self.data[key][valid_indices]
 
-    def convert_to_fraction_hour(self):
+    def convert_to_fraction_hour(self) -> None:
         time = self.data["time"]
         midnight = time[0].replace(hour=0, minute=0, second=0, microsecond=0)
         hour = datetime.timedelta(hours=1)
         self.data["time"] = (time - midnight) / hour
-        self.date = self.expected_date.split("-")  # type: ignore[union-attr]
 
-    def _store_ceilometer_info(self):
+    def _store_ceilometer_info(self) -> None:
         raise NotImplementedError
 
 
@@ -95,10 +88,15 @@ class ClCeilo(VaisalaCeilo):
 
     noise_param = NoiseParam(noise_min=3.1e-8, noise_smooth_min=1.1e-8)
 
-    def __init__(self, full_path, site_meta, expected_date=None):
+    def __init__(
+        self,
+        full_path: str | PathLike,
+        site_meta: dict,
+        expected_date: datetime.date | None = None,
+    ) -> None:
         super().__init__(read_cl_file, full_path, site_meta, expected_date)
 
-    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
@@ -111,11 +109,16 @@ class Ct25k(VaisalaCeilo):
 
     noise_param = NoiseParam(noise_min=0.7e-7, noise_smooth_min=1.2e-8)
 
-    def __init__(self, full_path, site_meta, expected_date=None):
+    def __init__(
+        self,
+        full_path: str | PathLike,
+        site_meta: dict,
+        expected_date: datetime.date | None = None,
+    ) -> None:
         super().__init__(read_ct_file, full_path, site_meta, expected_date)
         self._store_ceilometer_info()
 
-    def _store_ceilometer_info(self):
+    def _store_ceilometer_info(self) -> None:
         self.instrument = instruments.CT25K
 
 
@@ -124,8 +127,13 @@ class Cs135(VaisalaCeilo):
 
     noise_param = NoiseParam()
 
-    def __init__(self, full_path, site_meta, expected_date=None):
+    def __init__(
+        self,
+        full_path: str | PathLike,
+        site_meta: dict,
+        expected_date: datetime.date | None = None,
+    ) -> None:
         super().__init__(read_cs_file, full_path, site_meta, expected_date)
 
-    def _store_ceilometer_info(self):
+    def _store_ceilometer_info(self) -> None:
         self.instrument = instruments.CS135

cloudnetpy/instruments/weather_station.py

@@ -5,6 +5,7 @@ import re
 from collections import defaultdict
 from collections.abc import Iterable, Sequence
 from os import PathLike
+from uuid import UUID
 
 import numpy as np
 from numpy import ma
@@ -17,16 +18,16 @@ from cloudnetpy.exceptions import ValidTimeStampError
 from cloudnetpy.instruments import instruments
 from cloudnetpy.instruments.cloudnet_instrument import CSVFile
 from cloudnetpy.instruments.toa5 import read_toa5
-from cloudnetpy.utils import datetime2decimal_hours
+from cloudnetpy.utils import datetime2decimal_hours, get_uuid
 
 
 def ws2nc(
     weather_station_file: str | PathLike | Sequence[str | PathLike],
-    output_file: str,
+    output_file: str | PathLike,
     site_meta: dict,
-    uuid: str | None = None,
+    uuid: str | UUID | None = None,
     date: str | datetime.date | None = None,
-) -> str:
+) -> UUID:
     """Converts weather station data into Cloudnet Level 1b netCDF file.
 
     Args:
@@ -47,6 +48,7 @@ def ws2nc(
         weather_station_file = [weather_station_file]
     if isinstance(date, str):
         date = datetime.date.fromisoformat(date)
+    uuid = get_uuid(uuid)
     ws: WS
     if site_meta["name"] == "Palaiseau":
         ws = PalaiseauWS(weather_station_file, site_meta)
@@ -85,21 +87,26 @@ def ws2nc(
     ws.calculate_rainfall_amount()
     attributes = output.add_time_attribute({}, ws.date)
     output.update_attributes(ws.data, attributes)
-    return output.save_level1b(ws, output_file, uuid)
+    output.save_level1b(ws, output_file, uuid)
+    return uuid
 
 
 class WS(CSVFile):
-    def __init__(self, site_meta: dict):
+    def __init__(self, site_meta: dict) -> None:
         super().__init__(site_meta)
         self.instrument = instruments.GENERIC_WEATHER_STATION
 
-    date: list[str]
+    date: datetime.date
 
     def calculate_rainfall_amount(self) -> None:
         if "rainfall_amount" in self.data or "rainfall_rate" not in self.data:
             return
-        resolution = np.median(np.diff(self.data["time"].data)) * SEC_IN_HOUR
-        rainfall_amount = ma.cumsum(self.data["rainfall_rate"].data * resolution)
+        time = self.data["time"].data
+        if len(time) == 1:
+            rainfall_amount = np.array([0])
+        else:
+            resolution = np.median(np.diff(time)) * SEC_IN_HOUR
+            rainfall_amount = ma.cumsum(self.data["rainfall_rate"].data * resolution)
         self.data["rainfall_amount"] = CloudnetArray(rainfall_amount, "rainfall_amount")
 
     def screen_timestamps(self, date: datetime.date) -> None:
@@ -143,7 +150,7 @@ class WS(CSVFile):
 
 
 class PalaiseauWS(WS):
-    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
         super().__init__(site_meta)
         self.filenames = filenames
         self._data = self._read_data()
@@ -232,7 +239,7 @@ class BucharestWS(PalaiseauWS):
 
 
 class GranadaWS(WS):
-    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
         if len(filenames) != 1:
             raise ValueError
         super().__init__(site_meta)
@@ -282,7 +289,7 @@ class GranadaWS(WS):
 
 
 class KenttarovaWS(WS):
-    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
         super().__init__(site_meta)
         self.filenames = filenames
         self._data = self._read_data()
@@ -338,7 +345,7 @@ class HyytialaWS(WS):
     - BbRT/mm = Bucket content in real-time (Pluvio200) [mm].
     """
 
-    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
         super().__init__(site_meta)
         self.filename = filenames[0]
         self._data = self._read_data()
@@ -399,7 +406,7 @@ class HyytialaWS(WS):
 
 
 class GalatiWS(WS):
-    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
         super().__init__(site_meta)
         self.filename = filenames[0]
         self._data = self._read_data()
@@ -422,7 +429,7 @@ class GalatiWS(WS):
                             parsed_value = math.nan
                     raw_data[key].append(parsed_value)
 
-        def read_value(keys: Iterable[str]):
+        def read_value(keys: Iterable[str]) -> list:
             for key in keys:
                 if key in raw_data:
                     return raw_data[key]
@@ -443,7 +450,7 @@ class GalatiWS(WS):
 
     def add_data(self) -> None:
         # Skip wind measurements where range was limited to 0-180 degrees
-        if datetime.date(*map(int, self.date)) < datetime.date(2024, 10, 29):
+        if self.date < datetime.date(2024, 10, 29):
             del self._data["wind_speed"]
             del self._data["wind_direction"]
         return super().add_data()
@@ -454,7 +461,7 @@ class GalatiWS(WS):
 
 
 class JuelichWS(WS):
-    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
         super().__init__(site_meta)
         self.filename = filenames[0]
         self._data = self._read_data()
@@ -500,7 +507,7 @@ class JuelichWS(WS):
 class LampedusaWS(WS):
     """Read Lampedusa weather station data in ICOS format."""
 
-    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
         super().__init__(site_meta)
         self.filename = filenames[0]
         self._data = self._read_data()
@@ -553,7 +560,7 @@ class LampedusaWS(WS):
 
 
 class LimassolWS(WS):
-    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
         super().__init__(site_meta)
         self.filenames = filenames
         self._data = defaultdict(list)
@@ -610,7 +617,7 @@ class LimassolWS(WS):
         )  # mm/(10 min) -> m/s
 
 
-def _parse_sirta(filename: str | PathLike):
+def _parse_sirta(filename: str | PathLike) -> dict:
     """Parse SIRTA-style weather station file."""
     with open(filename, "rb") as f:
         raw_content = f.read()
@@ -653,7 +660,7 @@ def _parse_sirta(filename: str | PathLike):
 
 
 class LAquilaWS(WS):
-    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict):
+    def __init__(self, filenames: Sequence[str | PathLike], site_meta: dict) -> None:
         super().__init__(site_meta)
         self.filenames = filenames
         self._data = self._read_data()

cloudnetpy/model_evaluation/file_handler.py

@@ -1,7 +1,10 @@
 import os
 from datetime import datetime
+from os import PathLike
+from uuid import UUID
 
 import netCDF4
+import numpy.typing as npt
 
 from cloudnetpy import output, utils
 
@@ -62,11 +65,11 @@ def update_attributes(model_downsample_variables: dict, attributes: dict) -> Non
 
 def save_downsampled_file(
     id_mark: str,
-    file_name: str,
+    file_name: str | PathLike,
     objects: tuple,
-    files: tuple,
-    uuid: str | None,
-) -> str:
+    files: tuple[list[str | PathLike], str | PathLike],
+    uuid: UUID,
+) -> None:
     """Saves a standard downsampled day product file.
 
     Args:
@@ -82,36 +85,31 @@ def save_downsampled_file(
     """
     obj = objects[0]
     dimensions = {"time": len(obj.time), "level": len(obj.data["level"][:])}
-    root_group = output.init_file(file_name, dimensions, obj.data, uuid)
-    _augment_global_attributes(root_group)
-    uuid = root_group.file_uuid
-    root_group.cloudnet_file_type = "l3-" + id_mark.split("_")[0]
-    root_group.title = (
-        f"Downsampled {id_mark.capitalize().replace('_', ' of ')} "
-        f"from {obj.dataset.location}"
-    )
-    _add_source(root_group, objects, files)
-    output.copy_global(obj.dataset, root_group, ("location", "day", "month", "year"))
-    if not hasattr(obj.dataset, "day"):
-        root_group.year, root_group.month, root_group.day = obj.date
-    output.merge_history(root_group, id_mark, 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) -> None:
-    nc_file = netCDF4.Dataset(file_name, "r+", format="NETCDF4_CLASSIC")
-    _write_vars2nc(nc_file, obj.data)
-    nc_file.close()
+    with output.init_file(file_name, dimensions, obj.data, uuid) as root_group:
+        _augment_global_attributes(root_group)
+        root_group.cloudnet_file_type = "l3-" + id_mark.split("_")[0]
+        root_group.title = (
+            f"Downsampled {id_mark.capitalize().replace('_', ' of ')} "
+            f"from {obj.dataset.location}"
+        )
+        _add_source(root_group, objects, files)
+        output.copy_global(
+            obj.dataset, root_group, ("location", "day", "month", "year")
+        )
+        if not hasattr(obj.dataset, "day"):
+            root_group.year, root_group.month, root_group.day = obj.date
+        output.merge_history(root_group, id_mark, obj)
+
+
+def add_var2ncfile(obj: ModelManager, file_name: str | PathLike) -> None:
+    with netCDF4.Dataset(file_name, "r+", format="NETCDF4_CLASSIC") as nc_file:
+        _write_vars2nc(nc_file, obj.data)
 
 
 def _write_vars2nc(rootgrp: netCDF4.Dataset, cloudnet_variables: dict) -> None:
     """Iterates over Cloudnet-ME instances and write to given rootgrp."""
 
-    def _get_dimensions(array) -> tuple:
+    def _get_dimensions(array: npt.NDArray) -> tuple:
         """Finds correct dimensions for a variable."""
         if utils.isscalar(array):
             return ()