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

cloudnetpy/model_evaluation/products/observation_products.py

@@ -1,7 +1,9 @@
 import logging
 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
@@ -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
@@ -45,13 +47,13 @@ class ObservationManager(DataSource):
             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):
@@ -72,14 +74,14 @@ class ObservationManager(DataSource):
             logging.exception(msg)
             raise
 
-    def _generate_cf(self) -> np.ndarray:
+    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)
         return self._mask_cloud_bits(cloud_mask)
 
     @staticmethod
-    def _classify_basic_mask(bits: CategoryBits) -> np.ndarray:
+    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
@@ -90,7 +92,7 @@ class ObservationManager(DataSource):
         return cloud_mask
 
     @staticmethod
-    def _mask_cloud_bits(cloud_mask: np.ndarray) -> np.ndarray:
+    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
@@ -116,7 +118,7 @@ class ObservationManager(DataSource):
             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
@@ -130,13 +132,13 @@ 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:
+    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.
         """
@@ -144,7 +146,7 @@ class ObservationManager(DataSource):
         iwc_att[iwc_status > 3] = ma.masked
         self.append_data(iwc_att, "iwc_att")
 
-    def _get_rain_iwc(self, iwc_status: np.ndarray) -> None:
+    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

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,18 +14,19 @@ 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,
-) -> str:
+) -> 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
@@ -63,6 +66,7 @@ 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:
@@ -82,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_out = save_downsampled_file(
+            save_downsampled_file(
                 f"{obs}_{model}",
                 output_file,
                 (model_obj, product_obj),
@@ -91,4 +95,4 @@ def process_L3_day_product(
             )
         else:
             add_var2ncfile(model_obj, output_file)
-    return uuid_out
+    return uuid

cloudnetpy/model_evaluation/products/tools.py

@@ -1,28 +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:
+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")
             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))
@@ -34,7 +38,7 @@ def calculate_advection_time(
     resolution: int,
     wind: ma.MaskedArray,
     sampling: int,
-) -> np.ndarray:
+) -> npt.NDArray:
     """Calculates time which variable takes to go through the time window.
 
     Notes:
@@ -52,10 +56,10 @@ def calculate_advection_time(
 
 def get_1d_indices(
     window: tuple,
-    data: np.ndarray,
-    mask: np.ndarray | None = None,
-) -> np.ndarray:
-    indices: np.ndarray = np.array((window[0] <= data) & (data < window[-1]))
+    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
@@ -64,16 +68,16 @@ def get_1d_indices(
 def get_adv_indices(
     model_t: int,
     adv_t: float,
-    data: np.ndarray,
-    mask: np.ndarray | None = None,
-) -> np.ndarray:
+    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:
+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]
@@ -87,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:
+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,6 +3,7 @@ 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__)))
@@ -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

cloudnetpy/model_evaluation/tests/unit/test_plotting.py

@@ -1,34 +1,35 @@
 import pytest
 
 from cloudnetpy.model_evaluation.plotting import plotting as pl
+from cloudnetpy.model_evaluation.plotting.plot_meta import PlotMeta
 
 MODEL = "ecmwf"
-
-
-class VariableInfo:
-    def __init__(self):
-        self.name = "Product"
+VARIABLE_INFO = PlotMeta(
+    name="Product",
+    cbar="rainbow",
+    plot_range=(0, 1),
+    plot_scale="linear",
+    plot_type="mesh",
+)
 
 
 @pytest.mark.parametrize("key", ["cf_V", "cf_A", "cf_V_adv", "cf_A_adv"])
 def test_get_cf_title(key) -> None:
-    var = VariableInfo()
     field_name = key + "_" + MODEL
     value = "Product, Volume"
     if "A" in key:
         value = "Product, Area"
-    x = pl._get_cf_title(field_name, var)
+    x = pl._get_cf_title(field_name, VARIABLE_INFO)
     assert x == value
 
 
 @pytest.mark.parametrize("key", ["cf_V", "cf_A", "cf_V_adv", "cf_A_adv"])
 def test_get_cf_title_cycle(key) -> None:
-    var = VariableInfo()
     field_name = key + "_" + MODEL + "_001"
     value = "Product, Volume"
     if "A" in key:
         value = "Product, Area"
-    x = pl._get_cf_title(field_name, var)
+    x = pl._get_cf_title(field_name, VARIABLE_INFO)
     assert x == value
 
 
@@ -44,9 +45,8 @@ def test_get_cf_title_cycle(key) -> None:
     ],
 )
 def test_get_iwc_title(key, value) -> None:
-    var = VariableInfo()
     field_name = key + "_" + MODEL
-    x = pl._get_iwc_title(field_name, var)
+    x = pl._get_iwc_title(field_name, VARIABLE_INFO)
     assert x == value
 
 
@@ -62,23 +62,20 @@ def test_get_iwc_title(key, value) -> None:
     ],
 )
 def test_get_iwc_title_cycle(key, value) -> None:
-    var = VariableInfo()
     field_name = key + "_" + MODEL + "_001"
-    x = pl._get_iwc_title(field_name, var)
+    x = pl._get_iwc_title(field_name, VARIABLE_INFO)
     assert x == value
 
 
 def test_get_product_title() -> None:
-    var = VariableInfo()
     value = "Product"
-    x = pl._get_product_title(var)
+    x = pl._get_product_title(VARIABLE_INFO)
     assert x == value
 
 
 def test_get_product_title_cycle() -> None:
-    var = VariableInfo()
     value = "Product"
-    x = pl._get_product_title(var)
+    x = pl._get_product_title(VARIABLE_INFO)
     assert x == value
 
 
@@ -88,16 +85,14 @@ def test_get_product_title_cycle() -> None:
 )
 def test_get_stat_titles(key, title) -> None:
     field_name = key + "_" + MODEL
-    var = VariableInfo()
-    x = pl._get_stat_titles(field_name, key, var)
+    x = pl._get_stat_titles(field_name, key, VARIABLE_INFO)
     assert x == title
 
 
 @pytest.mark.parametrize("key", ["cf_V", "cf_A", "cf_V_adv", "cf_A_adv"])
 def test_get_cf_title_stat(key) -> None:
     field_name = key + "_" + MODEL
-    var = VariableInfo()
-    x = pl._get_cf_title_stat(field_name, var)
+    x = pl._get_cf_title_stat(field_name, VARIABLE_INFO)
     value = "Product volume"
     if "A" in key:
         value = "Product area"
@@ -114,13 +109,11 @@ def test_get_cf_title_stat(key) -> None:
 )
 def test_get_iwc_title_stat(key, value) -> None:
     field_name = key + "_" + MODEL
-    var = VariableInfo()
-    x = pl._get_iwc_title_stat(field_name, var)
+    x = pl._get_iwc_title_stat(field_name, VARIABLE_INFO)
     assert x == value
 
 
 @pytest.mark.parametrize("key", ["lwc"])
 def test_get_product_title_stat(key) -> None:
-    var = VariableInfo()
-    x = pl._get_product_title_stat(var)
+    x = pl._get_product_title_stat(VARIABLE_INFO)
     assert x == "Product"

cloudnetpy/model_evaluation/utils.py

@@ -1,6 +1,6 @@
 import os
-from pathlib import Path
+from os import PathLike
 
 
-def file_exists(file_path: str) -> bool:
-    return Path.is_file(Path(file_path)) and os.path.getsize(file_path) > 0
+def file_exists(file_path: str | PathLike) -> bool:
+    return os.path.isfile(file_path) and os.path.getsize(file_path) > 0

cloudnetpy/output.py

@@ -18,26 +18,20 @@ from cloudnetpy.metadata import COMMON_ATTRIBUTES
 
 
 def save_level1b(
-    obj,
+    obj,  # noqa: ANN001
     output_file: PathLike | str,
-    uuid: UUID | str | None = None,
-) -> str:
+    uuid: UUID,
+) -> None:
     """Saves Cloudnet Level 1b file."""
     dimensions = _get_netcdf_dimensions(obj)
     with init_file(output_file, dimensions, obj.data, uuid) as nc:
-        file_uuid = nc.file_uuid
         fix_attribute_name(nc)
         location = obj.site_meta["name"]
         nc.cloudnet_file_type = obj.instrument.domain
         nc.title = get_l1b_title(obj.instrument, location)
-        if isinstance(obj.date, list):
-            nc.year, nc.month, nc.day = obj.date
-        elif isinstance(obj.date, datetime.date):
-            nc.year = str(obj.date.year)
-            nc.month = str(obj.date.month).zfill(2)
-            nc.day = str(obj.date.day).zfill(2)
-        else:
-            raise TypeError
+        nc.year = str(obj.date.year)
+        nc.month = str(obj.date.month).zfill(2)
+        nc.day = str(obj.date.day).zfill(2)
         nc.location = location
         nc.history = get_l1b_history(obj.instrument)
         nc.source = get_l1b_source(obj.instrument)
@@ -47,10 +41,9 @@ def save_level1b(
             for software, version in obj.software.items():
                 nc.setncattr(f"{software}_version", version)
         nc.references = get_references()
-    return file_uuid
 
 
-def _get_netcdf_dimensions(obj) -> dict:
+def _get_netcdf_dimensions(obj) -> dict:  # noqa: ANN001
     dimensions = {
         key: len(obj.data[key][:]) for key in ("time", "range") if key in obj.data
     }
@@ -78,10 +71,10 @@ def _get_netcdf_dimensions(obj) -> dict:
 def save_product_file(
     short_id: str,
     obj: DataSource,
-    file_name: str,
-    uuid: str | None = None,
+    file_name: str | PathLike,
+    uuid: UUID,
     copy_from_cat: tuple = (),
-) -> str:
+) -> None:
     """Saves a standard Cloudnet product file.
 
     Args:
@@ -98,7 +91,6 @@ def save_product_file(
         "height": len(obj.dataset.variables["height"]),
     }
     with init_file(file_name, dimensions, obj.data, uuid) as nc:
-        file_uuid = nc.file_uuid
         nc.cloudnet_file_type = short_id
         vars_from_source = (
             "altitude",
@@ -121,7 +113,6 @@ def save_product_file(
         )
         merge_history(nc, human_readable_file_type, obj)
         nc.references = get_references(short_id)
-    return file_uuid
 
 
 def get_l1b_source(instrument: Instrument) -> str:
@@ -252,7 +243,7 @@ def init_file(
     file_name: PathLike | str,
     dimensions: dict,
     cloudnet_arrays: dict,
-    uuid: UUID | str | None = None,
+    uuid: UUID,
 ) -> netCDF4.Dataset:
     """Initializes a Cloudnet file for writing.
 
@@ -325,16 +316,11 @@ def copy_global(
 
 def add_time_attribute(
     attributes: dict,
-    date: list[str] | datetime.date,
+    date: datetime.date,
     key: str = "time",
 ) -> dict:
     """Adds time attribute with correct units."""
-    if isinstance(date, list):
-        date_str = "-".join(date)
-    elif isinstance(date, datetime.date):
-        date_str = date.isoformat()
-    else:
-        raise TypeError
+    date_str = date.isoformat()
     units = f"hours since {date_str} 00:00:00 +00:00"
     if key not in attributes:
         attributes[key] = COMMON_ATTRIBUTES[key]
@@ -436,13 +422,10 @@ def _get_identifier(short_id: str) -> str:
     return short_id
 
 
-def add_standard_global_attributes(
-    nc: netCDF4.Dataset,
-    uuid: UUID | str | None = None,
-) -> None:
+def add_standard_global_attributes(nc: netCDF4.Dataset, uuid: UUID) -> None:
     nc.Conventions = "CF-1.8"
     nc.cloudnetpy_version = version.__version__
-    nc.file_uuid = str(uuid) if uuid is not None else utils.get_uuid()
+    nc.file_uuid = str(uuid)
 
 
 def fix_attribute_name(nc: netCDF4.Dataset) -> None:

cloudnetpy/plotting/plotting.py

@@ -1,18 +1,20 @@
 """Misc. plotting routines for Cloudnet products."""
 
-import os.path
 import re
 import textwrap
 from dataclasses import dataclass
 from datetime import date
+from os import PathLike
 from typing import Any
 
 import matplotlib.pyplot as plt
 import netCDF4
 import numpy as np
+import numpy.typing as npt
 from matplotlib import rcParams
 from matplotlib.axes import Axes
 from matplotlib.colorbar import Colorbar
+from matplotlib.colorizer import ColorizingArtist
 from matplotlib.colors import ListedColormap
 from matplotlib.pyplot import Figure
 from matplotlib.ticker import AutoMinorLocator
@@ -83,12 +85,15 @@ class Dimensions:
         margin_left (int): Space between left edge of image and plotted data in pixels.
     """
 
-    def __init__(self, fig, axes, pad_inches: float | None = None):
+    def __init__(
+        self, fig: Figure, axes: list[Axes], pad_inches: float | None = None
+    ) -> None:
         if pad_inches is None:
             pad_inches = rcParams["savefig.pad_inches"]
 
+        renderer = fig.canvas.get_renderer()  # type: ignore[attr-defined]
         tightbbox = (
-            fig.get_tightbbox(fig.canvas.get_renderer())
+            fig.get_tightbbox(renderer)
             .padded(pad_inches)
             .transformed(Affine2D().scale(fig.dpi))
         )
@@ -112,7 +117,7 @@ class FigureData:
         file: netCDF4.Dataset,
         requested_variables: list[str],
         options: PlotParameters,
-    ):
+    ) -> None:
         self.file = file
         self.variables, self.indices = self._get_valid_variables_and_indices(
             requested_variables
@@ -231,7 +236,7 @@ class SubPlot:
         variable: netCDF4.Variable,
         options: PlotParameters,
         file_type: str | None,
-    ):
+    ) -> None:
         self.ax = ax
         self.variable = variable
         self.options = options
@@ -348,7 +353,7 @@ class SubPlot:
 
 
 class Plot:
-    def __init__(self, sub_plot: SubPlot):
+    def __init__(self, sub_plot: SubPlot) -> None:
         self.sub_plot = sub_plot
         self._data = sub_plot.variable[:]
         self._data_orig = self._data.copy()
@@ -389,7 +394,7 @@ class Plot:
     def _get_y_limits(self) -> tuple[float, float]:
         return 0, self.sub_plot.options.max_y
 
-    def _init_colorbar(self, plot) -> Colorbar:
+    def _init_colorbar(self, plot: ColorizingArtist) -> Colorbar:
         divider = make_axes_locatable(self._ax)
         cax = divider.append_axes("right", size="1%", pad=0.25)
         return plt.colorbar(plot, fraction=1.0, ax=self._ax, cax=cax)
@@ -476,7 +481,7 @@ class Plot:
 
 
 class Plot2D(Plot):
-    def plot(self, figure_data: FigureData):
+    def plot(self, figure_data: FigureData) -> None:
         self._convert_units()
         if figure_data.file_type == "cpr-simulation":
             min_x, max_x = 0, EARTHCARE_MAX_X
@@ -616,7 +621,12 @@ class Plot2D(Plot):
                 linestyles="dashed",
             )
 
-    def _plot_contour(self, figure_data: FigureData, alt: np.ndarray, **options):
+    def _plot_contour(
+        self,
+        figure_data: FigureData,
+        alt: npt.NDArray,
+        **options,  # noqa: ANN003
+    ) -> None:
         time_length = len(figure_data.time_including_gaps)
         step = max(1, time_length // 200)
         ind_time = np.arange(0, time_length, step)
@@ -882,11 +892,11 @@ class Plot1D(Plot):
 
 
 def generate_figure(
-    filename: os.PathLike | str,
+    filename: PathLike | str,
     variables: list[str],
     *,
     show: bool = True,
-    output_filename: os.PathLike | str | None = None,
+    output_filename: PathLike | str | None = None,
     options: PlotParameters | None = None,
 ) -> Dimensions:
     """Generate a figure based on the given filename and variables.
@@ -960,7 +970,7 @@ def generate_figure(
             plt.close(fig)
 
 
-def lin2log(*args) -> list:
+def lin2log(*args: npt.ArrayLike) -> list[ma.MaskedArray]:
     return [ma.log10(x) for x in args]