disdrodb 0.0.21__py3-none-any.whl → 0.1.1__py3-none-any.whl

disdrodb/api/checks.py

@@ -17,23 +17,22 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------.
 """DISDRODB Checks Functions."""
-
 import logging
 import os
 import re
+import warnings
+
+import numpy as np
 
-from disdrodb.api.info import infer_disdrodb_tree_path_components
 from disdrodb.api.path import (
+    define_data_dir,
     define_issue_dir,
     define_issue_filepath,
-    define_metadata_dir,
     define_metadata_filepath,
-    define_station_dir,
 )
 from disdrodb.utils.directories import (
     ensure_string_path,
     list_files,
-    remove_path_trailing_slash,
 )
 
 logger = logging.getLogger(__name__)
@@ -67,14 +66,10 @@ def check_url(url: str) -> bool:
     Returns
     -------
     bool
-        True if url well formatted, False if not well formatted.
+        ``True`` if url well formatted, ``False`` if not well formatted.
     """
     regex = r"^(https?:\/\/)?(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$"  # noqa: E501
-
-    if re.match(regex, url):
-        return True
-    else:
-        return False
+    return re.match(regex, url)
 
 
 def check_path_is_a_directory(dir_path, path_name=""):
@@ -87,21 +82,94 @@ def check_path_is_a_directory(dir_path, path_name=""):
 
 
 def check_directories_inside(dir_path):
-    """Check there are directories inside the specified dir_path."""
+    """Check there are directories inside the specified ``dir_path``."""
     dir_paths = os.listdir(dir_path)
     if len(dir_paths) == 0:
         raise ValueError(f"There are not directories within {dir_path}")
 
 
-def check_base_dir(base_dir: str):
-    """Raise an error if the path does not end with "DISDRODB"."""
-    base_dir = str(base_dir)  # convert Pathlib to string
-    if not base_dir.endswith("DISDRODB"):
-        raise ValueError(f"The path {base_dir} does not end with DISDRODB. Please check the path.")
-    return base_dir
+def check_data_archive_dir(data_archive_dir: str):
+    """Raise an error if the path does not end with ``DISDRODB``."""
+    data_archive_dir = str(data_archive_dir)  # convert Pathlib to string
+    data_archive_dir = os.path.normpath(data_archive_dir)
+    if not data_archive_dir.endswith("DISDRODB"):
+        raise ValueError(f"The path {data_archive_dir} does not end with DISDRODB. Please check the path.")
+    return data_archive_dir
+
 
+def check_metadata_archive_dir(metadata_archive_dir: str):
+    """Raise an error if the path does not end with ``DISDRODB``."""
+    metadata_archive_dir = str(metadata_archive_dir)  # convert Pathlib to string
+    metadata_archive_dir = os.path.normpath(metadata_archive_dir)
+    if not metadata_archive_dir.endswith("DISDRODB"):
+        raise ValueError(f"The path {metadata_archive_dir} does not end with DISDRODB. Please check the path.")
+    return metadata_archive_dir
 
-def check_sensor_name(sensor_name: str, product: str = "L0A") -> None:
+
+def check_measurement_interval(measurement_interval):
+    """Check measurement interval validity."""
+    if isinstance(measurement_interval, str) and measurement_interval == "":
+        raise ValueError("measurement_interval' must be specified as an integer value.")
+    if isinstance(measurement_interval, type(None)):
+        raise ValueError("measurement_interval' can not be None.")
+    if isinstance(measurement_interval, str) and not measurement_interval.isdigit():
+        raise ValueError("measurement_interval' is not a positive digit.")
+    return int(measurement_interval)
+
+
+def check_measurement_intervals(measurement_intervals):
+    """Check measurement interval.
+
+    Can be a list. It must be a positive natural number
+    """
+    if isinstance(measurement_intervals, (int, float, str)):
+        measurement_intervals = [measurement_intervals]
+    measurement_intervals = [check_measurement_interval(v) for v in measurement_intervals]
+    return measurement_intervals
+
+
+def check_sample_interval(sample_interval):
+    """Check sample_interval argument validity."""
+    if not isinstance(sample_interval, int):
+        raise ValueError("'sample_interval' must be an integer.")
+
+
+def check_rolling(rolling):
+    """Check rolling argument validity."""
+    if not isinstance(rolling, bool):
+        raise ValueError("'rolling' must be a boolean.")
+
+
+def check_folder_partitioning(folder_partitioning):
+    """
+    Check if the given folder partitioning scheme is valid.
+
+    Parameters
+    ----------
+    folder_partitioning : str or None
+        Defines the subdirectory structure based on the dataset's start time.
+        Allowed values are:
+          - "": No additional subdirectories, files are saved directly in data_dir.
+          - "year": Files are stored under a subdirectory for the year (<data_dir>/2025).
+          - "year/month": Files are stored under subdirectories by year and month (<data_dir>/2025/04).
+          - "year/month/day": Files are stored under subdirectories by year, month and day (<data_dir>/2025/04/01).
+          - "year/month_name": Files are stored under subdirectories by year and month name (<data_dir>/2025/April).
+          - "year/quarter": Files are stored under subdirectories by year and quarter (<data_dir>/2025/Q2).
+
+    Returns
+    -------
+    folder_partitioning
+        The verified folder partitioning scheme.
+    """
+    valid_options = ["", "year", "year/month", "year/month/day", "year/month_name", "year/quarter"]
+    if folder_partitioning not in valid_options:
+        raise ValueError(
+            f"Invalid folder_partitioning scheme '{folder_partitioning}'. Valid options are: {valid_options}.",
+        )
+    return folder_partitioning
+
+
+def check_sensor_name(sensor_name: str) -> None:
     """Check sensor name.
 
     Parameters
@@ -114,23 +182,22 @@ def check_sensor_name(sensor_name: str, product: str = "L0A") -> None:
     Raises
     ------
     TypeError
-        Error if `sensor_name` is not a string.
+        Error if ``sensor_name`` is not a string.
     ValueError
         Error if the input sensor name has not been found in the list of available sensors.
     """
     from disdrodb.api.configs import available_sensor_names
 
-    sensor_names = available_sensor_names(product=product)
+    sensor_names = available_sensor_names()
     if not isinstance(sensor_name, str):
         raise TypeError("'sensor_name' must be a string.")
     if sensor_name not in sensor_names:
-        msg = f"{sensor_name} not valid {sensor_name}. Valid values are {sensor_names}."
-        logger.error(msg)
+        msg = f"'{sensor_name}' is not a valid sensor_name. Valid values are {sensor_names}."
         raise ValueError(msg)
 
 
 def check_campaign_name(campaign_name):
-    """Check the campaign name is upper case !"""
+    """Check the campaign name is upper case !."""
     upper_campaign_name = campaign_name.upper()
     if campaign_name != upper_campaign_name:
         msg = f"The campaign directory name {campaign_name} must be defined uppercase: {upper_campaign_name}"
@@ -139,7 +206,7 @@ def check_campaign_name(campaign_name):
 
 
 def check_data_source(data_source):
-    """Check the data_source name is upper case !"""
+    """Check the data_source name is upper case !."""
     upper_data_source = data_source.upper()
     if data_source != upper_data_source:
         msg = f"The data source directory name {data_source} must be defined uppercase: {upper_data_source}"
@@ -149,9 +216,11 @@ def check_data_source(data_source):
 
 def check_product(product):
     """Check DISDRODB product."""
+    from disdrodb import PRODUCTS
+
     if not isinstance(product, str):
         raise TypeError("`product` must be a string.")
-    valid_products = ["RAW", "L0A", "L0B"]
+    valid_products = PRODUCTS
     if product.upper() not in valid_products:
         msg = f"Valid `products` are {valid_products}."
         logger.error(msg)
@@ -159,75 +228,183 @@ def check_product(product):
     return product
 
 
-def check_station_dir(product, data_source, campaign_name, station_name, base_dir=None):
-    """Check existence of the station data directory. If does not exists, raise an error."""
-    station_dir = define_station_dir(
-        product=product,
-        base_dir=base_dir,
-        data_source=data_source,
-        campaign_name=campaign_name,
-        station_name=station_name,
-        check_exists=False,
-    )
-    if not os.path.exists(station_dir) and os.path.isdir(station_dir):
-        msg = f"The station {station_name} data directory does not exist at {station_dir}."
-        logger.error(msg)
-        raise ValueError(msg)
-    return station_dir
+def check_product_kwargs(product, product_kwargs):
+    """Validate that product_kwargs for a given product contains exactly the required parameters.
 
+    Parameters
+    ----------
+    product : str
+        The product name (e.g., "L2E", "L2M").
+    product_kwargs : dict
+        Keyword arguments provided for this product.
+
+    Returns
+    -------
+    dict
+        The validated product_kwargs.
+
+    Raises
+    ------
+    ValueError
+        If required arguments are missing or if there are unexpected extra arguments.
+    """
+    from disdrodb import PRODUCTS_ARGUMENTS
+
+    required = set(PRODUCTS_ARGUMENTS.get(product, []))
+    provided = set(product_kwargs.keys())
+    missing = required - provided
+    extra = provided - required
+    if missing and extra:
+        raise ValueError(
+            f"For product '{product}', missing arguments: {sorted(missing)}, " f"unexpected arguments: {sorted(extra)}",
+        )
+    if missing:
+        raise ValueError(f"For product '{product}', missing arguments: {sorted(missing)}")
+    if extra:
+        raise ValueError(f"For product '{product}', unexpected arguments: {sorted(extra)}")
+    return product_kwargs
+
+
+def select_required_product_kwargs(product, product_kwargs):
+    """Select the required product arguments."""
+    from disdrodb import PRODUCTS_ARGUMENTS
+
+    required = set(PRODUCTS_ARGUMENTS.get(product, []))
+    provided = set(product_kwargs.keys())
+    missing = required - provided
+    # If missing, raise error
+    if missing:
+        raise ValueError(f"For product '{product}', missing arguments: {sorted(missing)}")
+    # Else return just required arguments
+    # --> e.g. for L0 no product arguments
+    return {k: product_kwargs[k] for k in required}
+
+
+def _check_fields(fields):
+    if fields is None:  # isinstance(fields, type(None)):
+        return fields
+    # Ensure is a list
+    if isinstance(fields, str):
+        fields = [fields]
+    # Remove duplicates
+    fields = np.unique(np.array(fields))
+    return fields
+
+
+def check_data_sources(data_sources):
+    """Check DISDRODB data sources."""
+    return _check_fields(data_sources)
 
-def has_available_station_files(product, data_source, campaign_name, station_name, base_dir=None):
-    """Return True if data are available for the given product and station."""
-    station_dir = check_station_dir(
+
+def check_campaign_names(campaign_names):
+    """Check DISDRODB campaign names."""
+    return _check_fields(campaign_names)
+
+
+def check_station_names(station_names):
+    """Check DISDRODB station names."""
+    return _check_fields(station_names)
+
+
+def check_invalid_fields_policy(invalid_fields):
+    """Check invalid fields policy."""
+    if invalid_fields not in ["raise", "warn", "ignore"]:
+        raise ValueError(
+            f"Invalid value for invalid_fields: {invalid_fields}. " "Valid values are 'raise', 'warn', or 'ignore'.",
+        )
+    return invalid_fields
+
+
+def check_valid_fields(fields, available_fields, field_name, invalid_fields_policy="raise"):
+    """Check if fields are valid."""
+    if fields is None:
+        return fields
+    if isinstance(fields, str):
+        fields = [fields]
+    fields = np.unique(np.array(fields))
+    invalid_fields_policy = check_invalid_fields_policy(invalid_fields_policy)
+    # Check for invalid fields
+    fields = np.array(fields)
+    is_valid = np.isin(fields, available_fields)
+    invalid_fields_values = fields[~is_valid].tolist()
+    fields = fields[is_valid].tolist()
+    # Error handling for invalid fields were found
+    if invalid_fields_policy == "warn" and invalid_fields_values:
+        warnings.warn(f"Ignoring invalid {field_name}: {invalid_fields_values}", UserWarning, stacklevel=2)
+    elif invalid_fields_policy == "raise" and invalid_fields_values:
+        raise ValueError(f"These {field_name} does not exist: {invalid_fields_values}.")
+    else:  # "ignore" silently drop invalid entries
+        pass
+    # If no valid fields left, raise error
+    if len(fields) == 0:
+        raise ValueError(f"All specified {field_name} do not exist !.")
+    return fields
+
+
+def has_available_data(
+    data_source,
+    campaign_name,
+    station_name,
+    product,
+    data_archive_dir=None,
+    # Product Options
+    **product_kwargs,
+):
+    """Return ``True`` if data are available for the given product and station."""
+    # Define product directory
+    data_dir = define_data_dir(
         product=product,
-        base_dir=base_dir,
+        data_archive_dir=data_archive_dir,
         data_source=data_source,
         campaign_name=campaign_name,
         station_name=station_name,
+        # Directory options
+        check_exists=False,
+        # Product Options
+        **product_kwargs,
     )
-    filepaths = list_files(station_dir, glob_pattern="*", recursive=True)
+    # If the product directory does not exists, return False
+    if not os.path.isdir(data_dir):
+        return False
+
+    # If no files, return False
+    filepaths = list_files(data_dir, glob_pattern="*", recursive=True)
     nfiles = len(filepaths)
     return nfiles >= 1
 
 
-def check_station_has_data(product, data_source, campaign_name, station_name, base_dir=None):
-    """Check the station data directory has data inside. If not, raise an error."""
-    if not has_available_station_files(
+def check_data_availability(
+    product,
+    data_source,
+    campaign_name,
+    station_name,
+    data_archive_dir=None,
+    # Product Options
+    **product_kwargs,
+):
+    """Check the station product data directory has files inside. If not, raise an error."""
+    if not has_available_data(
         product=product,
-        base_dir=base_dir,
+        data_archive_dir=data_archive_dir,
         data_source=data_source,
         campaign_name=campaign_name,
         station_name=station_name,
+        # Product Options
+        **product_kwargs,
     ):
         msg = f"The {product} station data directory of {data_source} {campaign_name} {station_name} is empty !"
-        logger.error(msg)
         raise ValueError(msg)
 
 
-def check_metadata_dir(product, data_source, campaign_name, base_dir=None):
-    """Check existence of the metadata directory. If does not exists, raise an error."""
-    metadata_dir = define_metadata_dir(
-        product=product, base_dir=base_dir, data_source=data_source, campaign_name=campaign_name, check_exists=False
-    )
-    if not os.path.exists(metadata_dir) and os.path.isdir(metadata_dir):
-        msg = f"The metadata directory does not exist at {metadata_dir}."
-        logger.error(msg)
-        raise ValueError(msg)
-    return metadata_dir
-
-
-def check_metadata_file(product, data_source, campaign_name, station_name, base_dir=None, check_validity=True):
+def check_metadata_file(metadata_archive_dir, data_source, campaign_name, station_name, check_validity=True):
     """Check existence of a valid metadata YAML file. If does not exists, raise an error."""
-    from disdrodb.metadata.checks import check_metadata_compliance
+    from disdrodb.metadata.checks import check_station_metadata
 
-    _ = check_metadata_dir(product=product, base_dir=base_dir, data_source=data_source, campaign_name=campaign_name)
     metadata_filepath = define_metadata_filepath(
-        product=product,
-        base_dir=base_dir,
+        metadata_archive_dir=metadata_archive_dir,
         data_source=data_source,
         campaign_name=campaign_name,
         station_name=station_name,
-        check_exists=False,
     )
     # Check existence
     if not os.path.exists(metadata_filepath):
@@ -240,20 +417,22 @@ def check_metadata_file(product, data_source, campaign_name, station_name, base_
 
     # Check validity
     if check_validity:
-        check_metadata_compliance(
-            base_dir=base_dir,
+        check_station_metadata(
+            metadata_archive_dir=metadata_archive_dir,
             data_source=data_source,
             campaign_name=campaign_name,
             station_name=station_name,
-            product=product,
         )
     return metadata_filepath
 
 
-def check_issue_dir(data_source, campaign_name, base_dir=None):
+def check_issue_dir(data_source, campaign_name, metadata_archive_dir=None):
     """Check existence of the issue directory. If does not exists, raise an error."""
     issue_dir = define_issue_dir(
-        base_dir=base_dir, data_source=data_source, campaign_name=campaign_name, check_exists=False
+        metadata_archive_dir=metadata_archive_dir,
+        data_source=data_source,
+        campaign_name=campaign_name,
+        check_exists=False,
     )
     if not os.path.exists(issue_dir) and os.path.isdir(issue_dir):
         msg = "The issue directory does not exist at {issue_dir}."
@@ -262,17 +441,18 @@ def check_issue_dir(data_source, campaign_name, base_dir=None):
     return issue_dir
 
 
-def check_issue_file(data_source, campaign_name, station_name, base_dir=None):
+def check_issue_file(data_source, campaign_name, station_name, metadata_archive_dir=None):
     """Check existence of a valid issue YAML file. If does not exists, raise an error."""
     from disdrodb.issue.checks import check_issue_compliance
+    from disdrodb.issue.writer import create_station_issue
 
     _ = check_issue_dir(
-        base_dir=base_dir,
+        metadata_archive_dir=metadata_archive_dir,
         data_source=data_source,
         campaign_name=campaign_name,
     )
     issue_filepath = define_issue_filepath(
-        base_dir=base_dir,
+        metadata_archive_dir=metadata_archive_dir,
         data_source=data_source,
         campaign_name=campaign_name,
         station_name=station_name,
@@ -280,171 +460,18 @@ def check_issue_file(data_source, campaign_name, station_name, base_dir=None):
     )
     # Check existence
     if not os.path.exists(issue_filepath):
-        msg = f"The issue YAML file of {data_source} {campaign_name} {station_name} does not exist at {issue_filepath}."
-        logger.error(msg)
-        raise ValueError(msg)
+        create_station_issue(
+            metadata_archive_dir=metadata_archive_dir,
+            data_source=data_source,
+            campaign_name=campaign_name,
+            station_name=station_name,
+        )
 
     # Check validity
     check_issue_compliance(
-        base_dir=base_dir,
+        metadata_archive_dir=metadata_archive_dir,
         data_source=data_source,
         campaign_name=campaign_name,
         station_name=station_name,
     )
     return issue_filepath
-
-
-def check_is_within_raw_directory(path):
-    """Check the path is within the DISDRODB 'Raw' directory."""
-    components = infer_disdrodb_tree_path_components(path)
-    if components[1] != "Raw":
-        msg = f"{path} is not within the 'Raw' directory."
-        logger.error(msg)
-        raise ValueError(msg)
-
-
-def check_is_within_processed_directory(path):
-    """Check the path is within the DISDRODB 'Processed' directory."""
-    components = infer_disdrodb_tree_path_components(path)
-    if components[1] != "Processed":
-        msg = f"{path} is not within the 'Processed' directory."
-        logger.error(msg)
-        raise ValueError(msg)
-
-
-def check_valid_campaign_dir(campaign_dir):
-    """Check the validity of a campaign directory path.
-
-    Used to check validity of 'raw_dir' and 'processed_dir'.
-
-    The path must represents this path */DISDRODB/<Raw or Processed>/<DATA_SOURCE>/<CAMPAIGN_NAME>
-    """
-    last_component = os.path.basename(campaign_dir)
-    tree_components = infer_disdrodb_tree_path_components(campaign_dir)
-    tree_path = "/".join(tree_components)
-    # Check that is not data_source or 'Raw'/Processed' directory
-    if len(tree_components) < 4:
-        msg = (
-            "Expecting the campaign directory path to comply with the pattern <...>/DISDRODB//<Raw or"
-            " Processed>/<DATA_SOURCE>/<CAMPAIGN_NAME>."
-        )
-        msg = msg + f"It only provides {tree_path}"
-        logger.error(msg)
-        raise ValueError(msg)
-    # Check that ends with the campaign_name
-    campaign_name = tree_components[3]
-    if last_component != campaign_name:
-        msg = (
-            "Expecting the campaign directory path to comply with the pattern  <...>/DISDRODB//<Raw or"
-            " Processed>/<DATA_SOURCE>/<CAMPAIGN_NAME>."
-        )
-        msg = msg + f"The 'campaign directory path {campaign_dir} does not end with '{campaign_name}'!"
-        logger.error(msg)
-        raise ValueError(msg)
-
-
-def check_raw_dir(raw_dir: str, station_name: str) -> None:
-    """Check validity of raw_dir content.
-
-    Steps:
-    1. Check that 'raw_dir' is a valid directory path
-    2. Check that 'raw_dir' follows the expect directory structure
-    3. Check that each station_name directory contains data
-    4. Check that for each station_name the mandatory metadata.yml is specified.
-    5. Check that for each station_name the mandatory issue.yml is specified.
-
-    Parameters
-    ----------
-    raw_dir : str
-        Input raw campaign directory.
-    station_name : str
-        Station name.
-    verbose : bool, optional
-        Whether to verbose the processing.
-        The default is False.
-
-    """
-    # Ensure valid path format
-    raw_dir = remove_path_trailing_slash(raw_dir)
-
-    # Check raw_dir is an existing directory
-    check_path_is_a_directory(raw_dir, path_name="raw_dir")
-
-    # Check is a valid campaign directory path
-    check_valid_campaign_dir(raw_dir)
-
-    # Check is inside the 'Raw' directory
-    check_is_within_raw_directory(raw_dir)
-
-    # Retrieve data_source and campaign_name
-    base_dir, product_type, data_source, campaign_name = infer_disdrodb_tree_path_components(raw_dir)
-
-    # Check <DATA_SOURCE> and <CAMPAIGN_NAME> are upper case
-    check_campaign_name(campaign_name)
-    check_data_source(data_source)
-
-    # Check there are directories in raw_dir
-    check_directories_inside(raw_dir)
-
-    # Check there is data in the station directory
-    check_station_has_data(
-        product="RAW",
-        base_dir=base_dir,
-        data_source=data_source,
-        campaign_name=campaign_name,
-        station_name=station_name,
-    )
-
-    # Check there is a valid metadata YAML file
-    check_metadata_file(
-        product="RAW",
-        base_dir=base_dir,
-        data_source=data_source,
-        campaign_name=campaign_name,
-        station_name=station_name,
-    )
-
-    # Check there is valid issue YAML file
-    check_issue_file(
-        base_dir=base_dir,
-        data_source=data_source,
-        campaign_name=campaign_name,
-        station_name=station_name,
-    )
-    return raw_dir
-
-
-def check_processed_dir(processed_dir):
-    """Check input, format and validity of the 'processed_dir' directory path.
-
-    Parameters
-    ----------
-    processed_dir : str
-        Path to the campaign directory in the 'DISDRODB/Processed directory tree
-
-    Returns
-    -------
-    str
-        Path of the processed campaign directory
-    """
-    # Check path type
-    processed_dir = ensure_string_path(processed_dir, msg="Provide 'processed_dir' as a string", accepth_pathlib=True)
-
-    # Ensure valid path format
-    processed_dir = remove_path_trailing_slash(processed_dir)
-
-    # Check is a valid campaign directory path
-    # - <...>/DISDRODB/Processed/<DATA_SOURCE>/<CAMPAIGN_NAME>
-    check_valid_campaign_dir(processed_dir)
-
-    # Check is inside the 'Processed' directory
-    check_is_within_processed_directory(processed_dir)
-
-    # Retrieve data_source and campaign_name
-    base_dir, product_type, data_source, campaign_name = infer_disdrodb_tree_path_components(processed_dir)
-
-    # Check <DATA_SOURCE> and <CAMPAIGN_NAME> are upper case
-    check_campaign_name(campaign_name)
-    check_data_source(data_source)
-
-    return processed_dir

disdrodb/api/configs.py

@@ -48,7 +48,7 @@ def get_sensor_configs_dir(sensor_name: str, product: str) -> str:
     ValueError
         Error if the config directory does not exist.
     """
-    check_sensor_name(sensor_name, product=product)
+    check_sensor_name(sensor_name)
     product = check_product(product)
     config_dir = define_config_dir(product=product)
     config_sensor_dir = os.path.join(config_dir, sensor_name)
@@ -79,7 +79,7 @@ def read_config_file(sensor_name: str, product: str, filename: str) -> dict:
     ValueError
         Error if file does not exist.
     """
-    check_sensor_name(sensor_name, product=product)
+    check_sensor_name(sensor_name)
     product = check_product(product)
     config_sensor_dir = get_sensor_configs_dir(sensor_name, product=product)
     config_filepath = os.path.join(config_sensor_dir, filename)
@@ -93,17 +93,13 @@ def read_config_file(sensor_name: str, product: str, filename: str) -> dict:
     return dictionary
 
 
-def available_sensor_names(product: str = "L0A") -> sorted:
+def available_sensor_names() -> list:
     """Get available names of sensors.
 
     Returns
     -------
     sensor_names: list
         Sorted list of the available sensors
-    product: str
-        DISDRODB product.
-        By default, it returns the sensors available for DISDRODB L0A products.
     """
-    product = check_product(product)
-    config_dir = define_config_dir(product=product)
+    config_dir = define_config_dir(product="L0A")
     return sorted(os.listdir(config_dir))