disdrodb 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

disdrodb/l0/readers/PARSIVEL2/VIETNAM/IGE_PARSIVEL2.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+# -----------------------------------------------------------------------------.
+# Copyright (c) 2021-2026 DISDRODB developers
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# -----------------------------------------------------------------------------.
+import os
+
+import pandas as pd
+
+from disdrodb.l0.l0_reader import is_documented_by, reader_generic_docstring
+from disdrodb.l0.l0a_processing import read_raw_text_file
+
+
+def reader_parsivel(filepath, logger):
+    """Reader for Parsivel CR1000 Data Logger file."""
+    ##------------------------------------------------------------------------.
+    #### Define reader options
+    reader_kwargs = {}
+    # - Define delimiter
+    reader_kwargs["delimiter"] = "\\n"
+    # - Skip first row as columns names
+    reader_kwargs["header"] = None
+    # - Skip first 3 rows
+    reader_kwargs["skiprows"] = 0
+    # - Define encoding
+    reader_kwargs["encoding"] = "latin"  # "ISO-8859-1"
+    # - Avoid first column to become df index !!!
+    reader_kwargs["index_col"] = False
+    # - Define behaviour when encountering bad lines
+    reader_kwargs["on_bad_lines"] = "skip"
+    # - Define reader engine
+    #   - C engine is faster
+    #   - Python engine is more feature-complete
+    reader_kwargs["engine"] = "python"
+    # - Define on-the-fly decompression of on-disk data
+    #   - Available: gzip, bz2, zip
+    reader_kwargs["compression"] = "infer"
+    # - Strings to recognize as NA/NaN and replace with standard NA flags
+    #   - Already included: '#N/A', '#N/A N/A', '#NA', '-1.#IND', '-1.#QNAN',
+    #                       '-NaN', '-nan', '1.#IND', '1.#QNAN', '<NA>', 'N/A',
+    #                       'NA', 'NULL', 'NaN', 'n/a', 'nan', 'null'
+    reader_kwargs["na_values"] = ["na", "", "error"]
+
+    ##------------------------------------------------------------------------.
+    #### Read the data
+    df_raw = read_raw_text_file(
+        filepath=filepath,
+        column_names=["TO_PARSE"],
+        reader_kwargs=reader_kwargs,
+        logger=logger,
+    )
+
+    # Retrieve header, number of columns and starting rows
+    # - Search in the first 3 rows where "TIMESTAMP" occurs
+    # - Once identified the row, strip away everything before TIMESTAMP
+    # - Then identify start_row_idx as the row where "TIMESTAMP" occurs + 2
+    for i in range(3):
+        line = df_raw.iloc[i]["TO_PARSE"]
+        if "TIMESTAMP" in line:
+            # Remove double and single quotes
+            line = line.replace('""', '"').replace('"', "")
+            # Define header
+            timestamp_idx = line.find("TIMESTAMP")
+            header_str = line[timestamp_idx:]
+            header = header_str.split(",")
+            # Define number of columns
+            n_columns = len(header)
+            # Define start row with data
+            start_row_idx = i + 3
+            break
+    else:
+        # start_row_idx = 0
+        # n_columns = len(df_raw["TO_PARSE"].iloc[0].split(","))
+        raise ValueError("Could not find 'TIMESTAMP' in the first 3 rows of the file.")
+
+    # Retrieve rows with actual data
+    df = df_raw.iloc[start_row_idx:]
+
+    # Expand dataframe
+    df = df["TO_PARSE"].str.split(",", expand=True, n=n_columns - 1)
+
+    #### Define column names
+    column_names = [
+        "time",
+        "RECORD",
+        "rainfall_rate_32bit",
+        "rainfall_accumulated_32bit",
+        "weather_code_synop_4680",
+        "weather_code_synop_4677",
+        "reflectivity_32bit",
+        "mor_visibility",
+        "laser_amplitude",
+        "number_particles",
+        "sensor_temperature",
+        "sensor_heating_current",
+        "sensor_battery_voltage",
+        "sample_interval",
+        "sensor_status",
+        "rain_kinetic_energy",
+        "sensor_temperature_receiver",
+        "sensor_temperature_trasmitter",
+        "V_Batt_Min",
+    ]
+
+    ##------------------------------------------------------------------------.
+    #### Assign column names
+    df.columns = column_names
+
+    ##------------------------------------------------------------------------.
+    #### Adapt the dataframe to adhere to DISDRODB L0 standards
+    # Define time as datetime column
+    df["time"] = pd.to_datetime(df["time"].str.strip('"'), format="%Y-%m-%d %H:%M:%S", errors="coerce")
+
+    # Drop columns not agreeing with DISDRODB L0 standards
+    columns_to_drop = [
+        "RECORD",
+        "V_Batt_Min",
+    ]
+    df = df.drop(columns=columns_to_drop, errors="ignore")
+    return df
+
+
+def reader_spectrum(filepath, logger):
+    """Reader for Spectrum CR1000 Data Logger file."""
+    ##------------------------------------------------------------------------.
+    #### Define column names
+    column_names = ["TO_PARSE"]
+
+    ##------------------------------------------------------------------------.
+    #### Define reader options
+    reader_kwargs = {}
+    # - Define delimiter
+    reader_kwargs["delimiter"] = "\\n"
+    # - Skip first row as columns names
+    reader_kwargs["header"] = None
+    # - Skip first 3 rows
+    reader_kwargs["skiprows"] = 4
+    # - Define encoding
+    reader_kwargs["encoding"] = "latin"  # "ISO-8859-1"
+    # - Avoid first column to become df index !!!
+    reader_kwargs["index_col"] = False
+    # - Define behaviour when encountering bad lines
+    reader_kwargs["on_bad_lines"] = "skip"
+    # - Define reader engine
+    #   - C engine is faster
+    #   - Python engine is more feature-complete
+    reader_kwargs["engine"] = "python"
+    # - Define on-the-fly decompression of on-disk data
+    #   - Available: gzip, bz2, zip
+    reader_kwargs["compression"] = "infer"
+    # - Strings to recognize as NA/NaN and replace with standard NA flags
+    #   - Already included: '#N/A', '#N/A N/A', '#NA', '-1.#IND', '-1.#QNAN',
+    #                       '-NaN', '-nan', '1.#IND', '1.#QNAN', '<NA>', 'N/A',
+    #                       'NA', 'NULL', 'NaN', 'n/a', 'nan', 'null'
+    reader_kwargs["na_values"] = ["na", "", "error"]
+
+    ##------------------------------------------------------------------------.
+    #### Read the data
+    df = read_raw_text_file(
+        filepath=filepath,
+        column_names=column_names,
+        reader_kwargs=reader_kwargs,
+        logger=logger,
+    )
+
+    ##------------------------------------------------------------------------.
+    #### Adapt the dataframe to adhere to DISDRODB L0 standards
+    # Split and assign columns
+    df = df["TO_PARSE"].str.split(",", n=2, expand=True)
+    df.columns = ["time", "RECORD", "TO_PARSE"]
+
+    # Define time in datetime format
+    df["time"] = pd.to_datetime(df["time"].str.strip('"'), format="%Y-%m-%d %H:%M:%S", errors="coerce")
+
+    # Keep only rows with valid number of values
+    df = df[df["TO_PARSE"].str.count(",") == 1085]
+
+    # Retrieve arrays
+    df_split = df["TO_PARSE"].str.split(",", expand=True)
+    raw_drop_concentration = df_split.iloc[:, :32].agg(",".join, axis=1).str.replace("-10", "0")
+    raw_drop_average_velocity = "0,0," + df_split.iloc[:, 32:62].agg(",".join, axis=1)
+    raw_drop_number = df_split.iloc[:, 62:].agg(",".join, axis=1)
+    df["raw_drop_concentration"] = raw_drop_concentration
+    df["raw_drop_average_velocity"] = raw_drop_average_velocity
+    df["raw_drop_number"] = raw_drop_number
+
+    # Drop columns not agreeing with DISDRODB L0 standards
+    df = df.drop(columns=["TO_PARSE", "RECORD"])
+    return df
+
+
+@is_documented_by(reader_generic_docstring)
+def reader(
+    filepath,
+    logger=None,
+):
+    """Reader."""
+    # Retrieve spectrum filepath
+    spectrum_filepath = filepath.replace("parsivel", "spectre")
+
+    # Read integral variables
+    df = reader_parsivel(filepath, logger=logger)
+
+    # Drop duplicates timesteps
+    df = df.drop_duplicates(subset="time", keep="first")
+
+    # Initialize empty arrays
+    # --> 0 values array produced in L0B
+    arrays_columns = ["raw_drop_concentration", "raw_drop_average_velocity", "raw_drop_number"]
+    for c in arrays_columns:
+        if c not in df:
+            df[c] = ""
+
+    # Add raw spectrum if available
+    if os.path.exists(spectrum_filepath):
+        # Read raw spectrum for corresponding timesteps
+        df_raw_spectrum = reader_spectrum(spectrum_filepath, logger=logger)
+        df_raw_spectrum = df_raw_spectrum.drop_duplicates(subset="time", keep="first")
+        # Add raw array to df
+        df = df.set_index("time")
+        df_raw_spectrum = df_raw_spectrum.set_index("time")
+        df.update(df_raw_spectrum)
+        # Set back time as column
+        df = df.reset_index()
+
+    # Return the dataframe adhering to DISDRODB L0 standards
+    return df

disdrodb/l0/template_tools.py

@@ -162,10 +162,11 @@ def _print_df_summary(df, indices, columns, print_column_names):
     df_summary = df_summary.loc[summary_stats]
     # Print summary stats
     for i, column in zip(indices, columns, strict=True):
-        tmp_df = df_summary[[column]]
-        tmp_df.columns = [""]
-        _print_column_index(i, column_name=column, print_column_names=print_column_names)
-        _print_value(tmp_df)
+        if column in df_summary:
+            tmp_df = df_summary[[column]]
+            tmp_df.columns = [""]
+            _print_column_index(i, column_name=column, print_column_names=print_column_names)
+            _print_value(tmp_df)
 
 
 def print_df_summary_stats(
@@ -192,19 +193,18 @@ def print_df_summary_stats(
     """
     # Define columns of interest
     _, columns_of_interest = _get_selected_column_names(df, column_indices)
-    # Remove columns of dtype object or string
-    indices_to_remove = np.where((df.dtypes == type(object)) | (df.dtypes == str))  # noqa
-    indices = np.arange(0, len(df.columns))
-    indices = indices[np.isin(indices, indices_to_remove, invert=True)]
-    columns = df.columns[indices]
+    # Select only numeric columns (remove columns of dtype object or string)
+    columns = df.select_dtypes(include="number").columns
+    indices = df.columns.get_indexer(columns)
     if len(columns) == 0:
         raise ValueError("No numeric columns in the dataframe.")
     # Select only columns of interest
-    idx_of_interest = np.where(np.isin(columns, columns_of_interest))[0]
-    if len(idx_of_interest) == 0:
+    mask = columns.isin(columns_of_interest)
+    columns = columns[mask]
+    indices = indices[mask]
+    if len(columns) == 0:
         raise ValueError("No numeric columns at the specified column_indices.")
-    columns = columns[idx_of_interest]
-    indices = indices[idx_of_interest]
+
     # Print summary stats
     _print_df_summary(df=df, indices=indices, columns=columns, print_column_names=print_column_names)
 

disdrodb/l1/classification.py

@@ -144,7 +144,7 @@ def qc_spikes_isolated_precip(hydrometeor_type, sample_interval):
 
     Parameters
     ----------
-    hydrometeor_type: xr.DataArray
+    hydrometeor_type: xarray.DataArray
         Hydrometeor type classification array with a ``time`` coordinate.
         Precipitation presence is defined where ``hydrometeor_type>= 1``.
     sample_interval : float or int
@@ -153,7 +153,7 @@ def qc_spikes_isolated_precip(hydrometeor_type, sample_interval):
 
     Returns
     -------
-    flag_spikes : xr.DataArray of int
+    flag_spikes : xarray.DataArray of int
         Binary QC flag array (same dimensions as input) with:
             * 0 : no spike detected
             * 1 : isolated precipitation spike
@@ -762,9 +762,13 @@ def classify_raw_spectrum(
 
     # ------------------------------------------------------------------------.
     #### Define precipitation type variable
-    precipitation_type = xr.ones_like(ds["time"], dtype=float) * -1
-    precipitation_type = xr.where(hydrometeor_type.isin([0]), 0, precipitation_type)
-    precipitation_type = xr.where(hydrometeor_type.isin([1, 2, 3]), 0, precipitation_type)
+    precipitation_type = xr.ones_like(ds["time"], dtype=float) * -2
+    precipitation_type = xr.where(hydrometeor_type.isin([0]), -1, precipitation_type)
+    precipitation_type = xr.where(
+        hydrometeor_type.isin([1, 2, 3, 9]),
+        0,
+        precipitation_type,
+    )  # 9 hail in rainfall class currently
     precipitation_type = xr.where(hydrometeor_type.isin([5, 6, 7, 8]), 1, precipitation_type)
     precipitation_type = xr.where(hydrometeor_type.isin([4]), 2, precipitation_type)
     precipitation_type.attrs.update(
@@ -837,7 +841,7 @@ def classify_raw_spectrum(
     # ------------------------------------------------------------------------
     #### Define QC splashing, strong_wind, margin_fallers, spikes
     # FUTURE: flag_spikes can be used for non hydrometeor classification,
-    # --> But caution because observing the below show true rainfall signature
+    # --> But caution because observing the below code show some true rainfall signature
     # --> raw_spectrum.isel(time=(flag_spikes == 0) & (precipitation_type == 0)).disdrodb.plot_spectrum()
 
     flag_splashing = xr.where((precipitation_type == 0) & (fraction_splash >= 0.1), 1, 0)

disdrodb/l2/empirical_dsd.py

@@ -106,7 +106,7 @@ def count_bins_with_drops(ds):
 
 def _compute_qc_bins_metrics(arr):
     # Find indices of non-zero elements
-    arr = arr.copy()
+    arr = np.asarray(arr).copy()
     arr[np.isnan(arr)] = 0
     non_zero_indices = np.nonzero(arr)[0]
     if non_zero_indices.size == 0:
@@ -117,13 +117,16 @@ def _compute_qc_bins_metrics(arr):
     segment = arr[start_idx : end_idx + 1]
 
     # Compute number of bins with drops
-    total_bins = segment.size
+    total_bins = len(non_zero_indices)
+
+    # Compute number of bins in the segment
+    segment_bins = segment.size
 
     # Compute number of missing bins (zeros)
     n_missing_bins = int(np.sum(segment == 0))
 
     # Compute fraction of bins with missing drops
-    fraction_missing = n_missing_bins / total_bins
+    fraction_missing = n_missing_bins / segment_bins
 
     # Identify longest with with consecutive zeros
     zero_mask = (segment == 0).astype(int)
@@ -152,14 +155,14 @@ def compute_qc_bins_metrics(ds):
     optionally collapses over velocity methods and the velocity dimension, then
     computes four metrics per time step:
 
-      1. Nbins: total number of diameter bins between the first and last non-zero count
-      2. Nbins_missing: number of bins with zero or NaN counts in that interval
-      3. Nbins_missing_fraction: fraction of missing bins (zeros) in the interval
+      1. Nbins: total number of diameter bins with non-zero count
+      2. Nbins_missing: number of bins with zero or NaN counts between the first and last non-zero count
+      3. Nbins_missing_fraction: fraction of missing bins (zeros) between the first and last non-zero count
       4. Nbins_missing_consecutive: maximum length of consecutive missing bins
 
     Parameters
     ----------
-    ds : xr.Dataset
+    ds : xarray.Dataset
         Input dataset containing one of the following variables:
         'drop_counts', 'drop_number_concentration', or 'drop_number'.
         If a 'velocity_method' dimension exists, only the first method is used.
@@ -167,7 +170,7 @@ def compute_qc_bins_metrics(ds):
 
     Returns
     -------
-    xr.Dataset
+    xarray.Dataset
         Dataset with a new 'metric' dimension of size 4 and coordinates:
         ['Nbins', 'Nbins_missing', 'Nbins_missing_fraction', 'Nbins_missing_consecutive'],
         indexed by 'time'.
@@ -298,7 +301,7 @@ def get_drop_number_concentration(drop_number, velocity, diameter_bin_width, sam
 
     Returns
     -------
-    drop_number_concentration : xarray.DataArray or ndarray
+    drop_number_concentration : xarray.DataArray or numpy.ndarray
         Array of drop number concentrations \\( N(D) \\) in m⁻³·mm⁻¹, representing
         the number of drops per unit volume per unit diameter interval.
 
@@ -355,7 +358,7 @@ def get_total_number_concentration(drop_number_concentration, diameter_bin_width
 
     Returns
     -------
-    total_number_concentration : xarray.DataArray or ndarray
+    total_number_concentration : xarray.DataArray or numpy.ndarray
         Total number concentration \\( N_t \\) in m⁻³, representing the total number
         of drops per unit volume.
 
@@ -692,8 +695,10 @@ def get_equivalent_reflectivity_factor(drop_number_concentration, diameter, diam
         dim=DIAMETER_DIMENSION,
         skipna=False,
     )
+    # Set to NaN where z <= 0
     invalid_mask = z > 0
     z = z.where(invalid_mask)
+
     # Compute equivalent reflectivity factor in dBZ
     # - np.log10(np.nan) returns -Inf !
     # --> We mask again after the log
@@ -741,8 +746,11 @@ def get_equivalent_reflectivity_spectrum(drop_number_concentration, diameter):
     """
     # Compute reflectivity in mm⁶·m⁻³
     z = drop_number_concentration * ((diameter * 1000) ** 6)
+
+    # Set to NaN where z <= 0
     invalid_mask = z > 0
     z = z.where(invalid_mask)
+
     # Compute equivalent reflectivity factor in dBZ
     # - np.log10(np.nan) returns -Inf !
     # --> We mask again after the log
@@ -930,6 +938,8 @@ def get_min_max_diameter(drop_counts):
     max_drop_diameter : xarray.DataArray
         Maximum diameter where drop_counts is non-zero, for each time step.
     """
+    # TODO: maybe use lower bound for minimum, and upper bound for maximum
+
     # Create a boolean mask where drop_counts is non-zero
     non_zero_mask = drop_counts > 0
 
@@ -1500,7 +1510,7 @@ def get_kinetic_energy_spectrum(
 
     Returns
     -------
-    xr.DataArray
+    xarray.DataArray
         Kinetic Energy Spectrum [J/m2/mm]
     """
     KE_spectrum = (
@@ -1718,9 +1728,9 @@ def compute_integral_parameters(
 
     Parameters
     ----------
-    drop_number_concentration : xr.DataArray
+    drop_number_concentration : xarray.DataArray
         Drop number concentration in each diameter bin [#/m3/mm].
-    velocity : xr.DataArray
+    velocity : xarray.DataArray
         Fall velocity of drops in each diameter bin [m/s].
         The presence of a velocity_method dimension enable to compute the parameters
         with different velocity estimates.
@@ -1873,9 +1883,9 @@ def compute_spectrum_parameters(
 
     Parameters
     ----------
-    drop_number_concentration : xr.DataArray
+    drop_number_concentration : xarray.DataArray
         Drop number concentration in each diameter bin [#/m3/mm].
-    velocity : xr.DataArray
+    velocity : xarray.DataArray
         Fall velocity of drops in each diameter bin [m/s].
         The presence of a velocity_method dimension enable to compute the parameters
         with different velocity estimates.

disdrodb/l2/processing.py

@@ -36,7 +36,7 @@ from disdrodb.l2.empirical_dsd import (
     get_rain_rate_from_drop_number,
 )
 from disdrodb.psd import create_psd, estimate_model_parameters
-from disdrodb.psd.fitting import compute_gof_stats
+from disdrodb.psd.gof_metrics import compute_gof_stats
 from disdrodb.utils.decorators import check_pytmatrix_availability
 from disdrodb.utils.manipulations import (
     define_diameter_array,
@@ -364,10 +364,12 @@ def generate_l2e(
     ds : xarray.Dataset
         DISDRODB L1 dataset.
         Alternatively, a xarray dataset with at least:
-            - variables: raw_drop_number
-            - dimension: DIAMETER_DIMENSION
-            - coordinates: diameter_bin_center, diameter_bin_width, sample_interval
-            - attributes: sensor_name
+
+        - variables: raw_drop_number
+        - dimension: DIAMETER_DIMENSION
+        - coordinates: diameter_bin_center, diameter_bin_width, sample_interval
+        - attributes: sensor_name
+
     ds_env : xarray.Dataset, optional
         Environmental dataset used for fall velocity and water density estimates.
         If None, a default environment dataset will be loaded.
@@ -642,10 +644,12 @@ def generate_l2e(
 def _get_default_optimization(psd_model):
     """PSD model defaults."""
     defaults = {
-        "ExponentialPSD": "ML",
-        "GammaPSD": "ML",
-        "LognormalPSD": "ML",
+        "ExponentialPSD": "GS",
+        "GammaPSD": "GS",
+        "LognormalPSD": "GS",
         "NormalizedGammaPSD": "GS",
+        "GeneralizedGammaPSD": "GS",
+        "NormalizedGeneralizedGammaPSD": "GS",
     }
     optimization = defaults[psd_model]
     return optimization
@@ -695,7 +699,7 @@ def generate_l2m(
     psd_model,
     # Fitting options
     optimization=None,
-    optimization_kwargs=None,
+    optimization_settings=None,
     # PSD discretization
     diameter_min=0,
     diameter_max=10,
@@ -735,7 +739,7 @@ def generate_l2m(
     optimization : str, optional
         The fitting optimization procedure. Either "GS" (Grid Search), "ML (Maximum Likelihood)
         or "MOM" (Method of Moments).
-    optimization_kwargs : dict, optional
+    optimization_settings : dict, optional
         Dictionary with arguments to customize the fitting procedure.
     minimum_nbins: int
         Minimum number of bins with drops required to fit the PSD model.
@@ -786,7 +790,7 @@ def generate_l2m(
         ds=ds,
         psd_model=psd_model,
         optimization=optimization,
-        optimization_kwargs=optimization_kwargs,
+        optimization_settings=optimization_settings,
     )
     psd_fitting_attrs = ds_psd_params.attrs
 
@@ -841,6 +845,20 @@ def generate_l2m(
         "drop_number_concentration",
         "fall_velocity",
         "N",
+        # L0C QC
+        "qc_time",
+        # L1 flags and variables
+        "qc_resampling",
+        "n_margin_fallers",
+        "n_splashing",
+        "flag_graupel",
+        "flag_hail",
+        "flag_spikes",
+        "flag_splashing",
+        "flag_wind_artefacts",
+        # L2E drop statistics
+        "Dmin",
+        "Dmax",
         *METEOROLOGICAL_VARIABLES,
     ]
     variables = [var for var in variables if var in ds]
@@ -885,12 +903,12 @@ def generate_l2_radar(
     ----------
     ds : xarray.Dataset
         Dataset containing the drop number concentration variable or the PSD parameters.
-    frequency : str, float, or list of str and float, optional
+    frequency : str, float, or list of str or float, optional
         Frequencies in GHz for which to compute the radar parameters.
         Alternatively, also strings can be used to specify common radar frequencies.
         If ``None``, the common radar frequencies will be used.
         See ``disdrodb.scattering.available_radar_bands()``.
-    num_points: int or list of integer, optional
+    num_points: int or list of int, optional
         Number of bins into which discretize the PSD.
     diameter_max : float or list of float, optional
         Maximum diameter. The default value is 10 mm.
@@ -899,7 +917,7 @@ def generate_l2_radar(
     axis_ratio_model : str or list of str, optional
         Models to compute the axis ratio. The default model is ``Thurai2007``.
         See available models with ``disdrodb.scattering.available_axis_ratio_models()``.
-    permittivity_model : str str or list of str, optional
+    permittivity_model : str or list of str, optional
         Permittivity model to use to compute the refractive index and the
         rayleigh_dielectric_factor. The default is ``Turner2016``.
         See available models with ``disdrodb.scattering.available_permittivity_models()``.

disdrodb/metadata/download.py

@@ -38,7 +38,7 @@ def download_metadata_archive(directory_path, force=False):
 
     Returns
     -------
-    metadata_archive_dir
+    str
         The DISDRODB Metadata Archive directory path.
     """
     # Define DISDRODB Metadata Archive GitHub URL

disdrodb/metadata/geolocation.py

@@ -97,10 +97,10 @@ def infer_altitudes(lats, lons, dem="aster30m"):
 
     Notes
     -----
-    - The OpenTopoData API has a limit of 1000 calls per day.
-    - Each request can include up to 100 locations.
-    - The API allows a maximum of 1 call per second.
-    - The API requests are made in blocks of up to 100 coordinates,
+    The OpenTopoData API has a limit of 1000 calls per day.
+    Each request can include up to 100 locations.
+    The API allows a maximum of 1 call per second.
+    The API requests are made in blocks of up to 100 coordinates,
     with a 2-second delay between requests.
     """
     # Check that lats and lons have the same length

disdrodb/metadata/reader.py

@@ -73,13 +73,13 @@ def read_metadata_archive(
     metadata_archive_dir : str or Path-like, optional
         Path to the root of the DISDRODB Metadata Archive. If None, the
         default metadata base directory is used. Default is None.
-    data_sources : str or sequence of str, optional
+    data_sources : str or list of str, optional
         One or more data source identifiers to filter stations by. If None,
         no filtering on data source is applied. The default is is None.
-    campaign_names : str or sequence of str, optional
+    campaign_names : str or list of str, optional
         One or more campaign names to filter stations by. If None, no filtering
         on campaign is applied. The default is is None.
-    station_names : str or sequence of str, optional
+    station_names : str or list of str, optional
         One or more station names to include. If None, all stations matching
         other filters are considered. The default is is None.
     available_data: bool, optional

disdrodb/metadata/search.py

@@ -59,40 +59,42 @@ def get_list_metadata(
 
             - if available_data is False, return metadata filepaths of stations present in the DISDRODB Metadata Archive
             - if available_data is True, return metadata filepaths of stations with data available on the
-            online DISDRODB Decentralized Data Archive (i.e., stations with the disdrodb_data_url in the metadata).
+              online DISDRODB Decentralized Data Archive (i.e., stations with the disdrodb_data_url in the metadata).
 
         If ``product`` is specified:
 
             - if available_data is False, return metadata filepaths of stations where
-            the product directory exists in the in the local DISDRODB Data Archive
+              the product directory exists in the in the local DISDRODB Data Archive
             - if available_data is True, return metadata filepaths of stations where product data exists in the
               in the local DISDRODB Data Archive.
+
         The default is is False.
 
-    data_sources : str or sequence of str, optional
+    data_sources : str or list of str, optional
         One or more data source identifiers to filter stations by.
         The name(s) must be UPPER CASE.
         If None, no filtering on data source is applied. The default is is ``None``.
-    campaign_names : str or sequence of str, optional
+    campaign_names : str or list of str, optional
         One or more campaign names to filter stations by.
         The name(s) must be UPPER CASE.
         If None, no filtering on campaign is applied. The default is is ``None``.
-    station_names : str or sequence of str, optional
+    station_names : str or list of str, optional
         One or more station names to include.
         If None, all stations matching other filters are considered. The default is is ``None``.
     raise_error_if_empty : bool, optional
         If True and no stations satisfy the criteria, raise a ``ValueError``.
         If False, return an empty list/tuple. The default is False.
-    invalid_fields_policy : {'raise', 'warn', 'ignore'}, optional
+    invalid_fields_policy : str, optional
         How to handle invalid filter values for ``data_sources``, ``campaign_names``,
-        or ``station_names`` that are not present in the metadata archive:
+        or ``station_names`` that are not present in the metadata archive. Valid options are:
 
           - 'raise' : raise a ``ValueError`` (default)
           - 'warn'  : emit a warning, then ignore invalid entries
           - 'ignore': silently drop invalid entries
+
     data_archive_dir : str or Path-like, optional
         Path to the root of the local DISDRODB Data Archive. Format: ``<...>/DISDRODB``
-        Required only if ``product``is specified.
+        Required only if ``product`` is specified.
         If None, the``data_archive_dir`` path specified in the DISDRODB active configuration file is used.
         The default is None.
     metadata_archive_dir : str or Path-like, optional