rainfallqc 0.2.4__tar.gz → 0.2.5__tar.gz

{rainfallqc-0.2.4 → rainfallqc-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rainfallqc
-Version: 0.2.4
+Version: 0.2.5
 Summary: Quality control for rainfall data
 Author-email: Tom Keel <tomkee@ceh.ac.uk>
 Maintainer-email: Tom Keel <tomkee@ceh.ac.uk>
@@ -92,49 +92,41 @@ Example 1. - Individual quality checks on single rain gauge
 
 .. code-block:: python
 
-        # Load two types of QC'ing modules from RainfallQC
         from rainfallqc import gauge_checks, comparison_checks
 
-        # 1. Simple 1 gauge QC
-        # 1.1. Run 1 qc method for 1 gauge
+        data = pl.read_csv("rain_gauge_data.csv")
         intermittency_flag = gauge_checks.check_intermittency(data, target_gauge_col="rain_mm")
 
-        # 1.2. Run 1 qc method for 1 gauge using in-built comparison dataset
-        wr_flags = comparison_checks.check_exceedance_of_rainfall_world_record(data, target_gauge_col="rain_mm", time_res='hourly')
-
-        # 1.3. Run 1 qc method for 1 gauge using in-built comparison dataset and location of gauge
-        rx1day_flags = comparison_checks.check_annual_exceedance_etccdi_rx1day(data, target_gauge_col="rain_mm", gauge_lon=1.0, gauge_lat=55.0)
-
-
-Example 2. - Individual quality checks on networks of rain gauges
-=================================================================
+Example 2. - Neighbourhood quality checks for the global sub-daily rain gauge network (GSDR)
+============================================================================================
 
 .. code-block:: python
 
-        # 2. Run neighbour/network checks on a subset of a rain gauge network
         from rainfallqc import neighbourhood_checks
         from rainfallqc.utils import data_readers
 
-        # 2.1. Read in GDSR gauge network metadata
-        gdsr_obj = data_readers.GDSRNetworkReader(path_to_gdsr_dir="./tests/data/GDSR/")
+        distance_threshold = 50  # km
+        n_closest = 10 # number of closest neighbours to consider
+        min_overlap_days = 500  # minimum overlapping days to be considered a neighbour
+
+        gsdr_obj = data_readers.GSDRNetworkReader(path_to_gsdr_dir="path/to/GSDR/data")
 
-        # 2.2. subset by max 10 gauges within 50 km and with at least 500 days of overlap
         nearby_ids = list(
-            gdsr_obj.get_nearest_overlapping_neighbours_to_target(
-                target_id="DE_00310", distance_threshold=50, n_closest=10, min_overlap_days=500
+            gsdr_obj.get_nearest_overlapping_neighbours_to_target(
+                target_id="DE_00310", distance_threshold=distance_threshold, n_closest=n_closest, min_overlap_days=min_overlap_days
             )
         )
         nearby_ids.append(target_id)
-        nearby_data_paths = gdsr_obj.metadata.filter(pl.col("station_id").is_in(nearby_ids))["path"]
+        nearby_data_paths = gsdr_obj.metadata.filter(pl.col("station_id").is_in(nearby_ids))["path"]
 
-        # 2.3. Load those nearest gauges from network metadata
-        gdsr_network = gdsr_obj.load_network_data(data_paths=nearby_data_paths)
+        # Load those nearest gauges from network metadata
+        gsdr_network = gsdr_obj.load_network_data(data_paths=nearby_data_paths)
 
-        # 2.4 Run a neighbourhood check (checking if suspiciously large rainfall values were seen in neighbours)
+        # Run wet neighbour check
         extreme_wet_flags = neighbourhood_checks.check_wet_neighbours(
-            gdsr_network,
+            gsdr_network,
             target_gauge_col="rain_mm_DE_02483",
-            neighbouring_gauge_cols=gdsr_network.columns[1:],  # exclude time
+            neighbouring_gauge_cols=gsdr_network.columns[1:],  # exclude time
             time_res="hourly",
             wet_threshold=1.0, # threshold for rainfall intensity to be considered
             min_n_neighbours=5, # number of neighbours needed for comparison
@@ -146,14 +138,13 @@ Example 3. - Applying a framework of QC methods (e.g. IntenseQC)
 
 .. code-block:: python
 
-        # 3. Applying multiple QC methods in framework (e.g. IntenseQC)
         from rainfallqc.qc_frameworks import apply_qc_framework
 
-        # 3.1. Decide which QC methods of IntenseQC will be run
+        # 1. Decide which QC methods of IntenseQC will be run
         qc_framework = "IntenseQC"
         qc_methods_to_run = ["QC1", "QC8", "QC9", "QC10", "QC11", "QC12", "QC14", "QC15", "QC16"]
 
-        # 3.2 Decide which parameters for QC
+        # 2 Decide which parameters for QC
         qc_kwargs = {
             "QC1": {"quantile": 5},
             "QC14": {"wet_day_threshold": 1.0, "accumulation_multiplying_factor": 2.0},
@@ -173,7 +164,7 @@ Example 3. - Applying a framework of QC methods (e.g. IntenseQC)
             },
         }
 
-        # 3.3. Run QC methods on network data
+        # 3. Run QC methods on network data
         qc_result = apply_qc_framework.run_qc_framework(
             daily_gpcc_network, qc_framework=qc_framework, qc_methods_to_run=qc_methods_to_run, qc_kwargs=qc_kwargs
         )

{rainfallqc-0.2.4 → rainfallqc-0.2.5}/README.rst

@@ -34,49 +34,41 @@ Example 1. - Individual quality checks on single rain gauge
 
 .. code-block:: python
 
-        # Load two types of QC'ing modules from RainfallQC
         from rainfallqc import gauge_checks, comparison_checks
 
-        # 1. Simple 1 gauge QC
-        # 1.1. Run 1 qc method for 1 gauge
+        data = pl.read_csv("rain_gauge_data.csv")
         intermittency_flag = gauge_checks.check_intermittency(data, target_gauge_col="rain_mm")
 
-        # 1.2. Run 1 qc method for 1 gauge using in-built comparison dataset
-        wr_flags = comparison_checks.check_exceedance_of_rainfall_world_record(data, target_gauge_col="rain_mm", time_res='hourly')
-
-        # 1.3. Run 1 qc method for 1 gauge using in-built comparison dataset and location of gauge
-        rx1day_flags = comparison_checks.check_annual_exceedance_etccdi_rx1day(data, target_gauge_col="rain_mm", gauge_lon=1.0, gauge_lat=55.0)
-
-
-Example 2. - Individual quality checks on networks of rain gauges
-=================================================================
+Example 2. - Neighbourhood quality checks for the global sub-daily rain gauge network (GSDR)
+============================================================================================
 
 .. code-block:: python
 
-        # 2. Run neighbour/network checks on a subset of a rain gauge network
         from rainfallqc import neighbourhood_checks
         from rainfallqc.utils import data_readers
 
-        # 2.1. Read in GDSR gauge network metadata
-        gdsr_obj = data_readers.GDSRNetworkReader(path_to_gdsr_dir="./tests/data/GDSR/")
+        distance_threshold = 50  # km
+        n_closest = 10 # number of closest neighbours to consider
+        min_overlap_days = 500  # minimum overlapping days to be considered a neighbour
+
+        gsdr_obj = data_readers.GSDRNetworkReader(path_to_gsdr_dir="path/to/GSDR/data")
 
-        # 2.2. subset by max 10 gauges within 50 km and with at least 500 days of overlap
         nearby_ids = list(
-            gdsr_obj.get_nearest_overlapping_neighbours_to_target(
-                target_id="DE_00310", distance_threshold=50, n_closest=10, min_overlap_days=500
+            gsdr_obj.get_nearest_overlapping_neighbours_to_target(
+                target_id="DE_00310", distance_threshold=distance_threshold, n_closest=n_closest, min_overlap_days=min_overlap_days
             )
         )
         nearby_ids.append(target_id)
-        nearby_data_paths = gdsr_obj.metadata.filter(pl.col("station_id").is_in(nearby_ids))["path"]
+        nearby_data_paths = gsdr_obj.metadata.filter(pl.col("station_id").is_in(nearby_ids))["path"]
 
-        # 2.3. Load those nearest gauges from network metadata
-        gdsr_network = gdsr_obj.load_network_data(data_paths=nearby_data_paths)
+        # Load those nearest gauges from network metadata
+        gsdr_network = gsdr_obj.load_network_data(data_paths=nearby_data_paths)
 
-        # 2.4 Run a neighbourhood check (checking if suspiciously large rainfall values were seen in neighbours)
+        # Run wet neighbour check
         extreme_wet_flags = neighbourhood_checks.check_wet_neighbours(
-            gdsr_network,
+            gsdr_network,
             target_gauge_col="rain_mm_DE_02483",
-            neighbouring_gauge_cols=gdsr_network.columns[1:],  # exclude time
+            neighbouring_gauge_cols=gsdr_network.columns[1:],  # exclude time
             time_res="hourly",
             wet_threshold=1.0, # threshold for rainfall intensity to be considered
             min_n_neighbours=5, # number of neighbours needed for comparison
@@ -88,14 +80,13 @@ Example 3. - Applying a framework of QC methods (e.g. IntenseQC)
 
 .. code-block:: python
 
-        # 3. Applying multiple QC methods in framework (e.g. IntenseQC)
         from rainfallqc.qc_frameworks import apply_qc_framework
 
-        # 3.1. Decide which QC methods of IntenseQC will be run
+        # 1. Decide which QC methods of IntenseQC will be run
         qc_framework = "IntenseQC"
         qc_methods_to_run = ["QC1", "QC8", "QC9", "QC10", "QC11", "QC12", "QC14", "QC15", "QC16"]
 
-        # 3.2 Decide which parameters for QC
+        # 2 Decide which parameters for QC
         qc_kwargs = {
             "QC1": {"quantile": 5},
             "QC14": {"wet_day_threshold": 1.0, "accumulation_multiplying_factor": 2.0},
@@ -115,7 +106,7 @@ Example 3. - Applying a framework of QC methods (e.g. IntenseQC)
             },
         }
 
-        # 3.3. Run QC methods on network data
+        # 3. Run QC methods on network data
         qc_result = apply_qc_framework.run_qc_framework(
             daily_gpcc_network, qc_framework=qc_framework, qc_methods_to_run=qc_methods_to_run, qc_kwargs=qc_kwargs
         )

{rainfallqc-0.2.4 → rainfallqc-0.2.5}/pyproject.toml

@@ -68,7 +68,7 @@ homepage = "https://github.com/thomasjkeel/RainfallQC"
 target-version = ["py310", "py311", "py312", "py313"]
 
 [tool.bumpversion]
-current_version = "0.2.4"
+current_version = "0.2.5"
 commit = true
 message = "Bump version: {current_version} → {new_version}"
 commit_args = ""

{rainfallqc-0.2.4 → rainfallqc-0.2.5}/src/rainfallqc/__init__.py

@@ -2,7 +2,7 @@
 
 __author__ = """Tom Keel"""
 __email__ = "tomkee@ceh.ac.uk"
-__version__ = "0.2.4"
+__version__ = "0.2.5"
 
 from rainfallqc import core, utils
 from rainfallqc.checks import (

{rainfallqc-0.2.4 → rainfallqc-0.2.5}/src/rainfallqc/utils/data_readers.py

@@ -21,24 +21,24 @@ import xarray as xr
 from rainfallqc.utils import data_utils, neighbourhood_utils
 
 MULTIPLYING_FACTORS = {"hourly": 24, "daily": 1}  # compared to daily reference
-GDSR_TIME_RES_CONVERSION = {"1hr": "hourly", "1d": "daily", "1mo": "monthly"}
+GSDR_TIME_RES_CONVERSION = {"1hr": "hourly", "1d": "daily", "1mo": "monthly"}
 GPCC_TIME_RES_CONVERSION = {"tw": "daily", "mw": "monthly"}
-GPCC_HOUR_OFFSET = 7  # Apparently the GDSR data runs from 7am to 7am, so this converts it for comparison
+GPCC_HOUR_OFFSET = 7  # Apparently the GSDR data runs from 7am to 7am, so this converts it for comparison
 
 
-def read_gdsr_metadata(data_path: str) -> dict:
+def read_gsdr_metadata(data_path: str) -> dict:
     """
-    Read the specific format and header of Global Sub-Daily Rainfall (GDSR) files.
+    Read the specific format and header of Global Sub-Daily Rainfall (GSDR) files.
 
     Parameters
     ----------
     data_path :
-        path to GDSR data file (.txt)
+        path to GSDR data file (.txt)
 
     Returns
     -------
     metadata :
-        Metadata from GDSR file
+        Metadata from GSDR file
 
     """
     metadata = {}
@@ -51,7 +51,7 @@ def read_gdsr_metadata(data_path: str) -> dict:
                 metadata[key] = val
                 if key == "other":
                     break
-    metadata = convert_gdsr_metadata_dates_to_datetime(metadata)
+    metadata = convert_gsdr_metadata_dates_to_datetime(metadata)
     return metadata
 
 
@@ -116,23 +116,23 @@ def read_gpcc_metadata_from_zip(data_path: str, time_res: str, gpcc_file_format:
     return gpcc_metadata
 
 
-def read_gdsr_data_from_file(
+def read_gsdr_data_from_file(
     data_path: str,
     raw_data_time_res: str,
     rain_col_prefix: str = None,
     rain_col_suffix: str = None,
     suffix_only: bool = False,
-    gdsr_header_rows: int = 20,
+    gsdr_header_rows: int = 20,
 ) -> pl.DataFrame:
     """
-    Read GDSR data from file.
+    Read GSDR data from file.
 
-    Note: this was developed on the GDSR data available from IntenseQC. So it needs a number of header rows in data.
+    Note: this was developed on the GSDR data available from IntenseQC. So it needs a number of header rows in data.
 
     Parameters
     ----------
     data_path :
-        Path to GDSR data file
+        Path to GSDR data file
     raw_data_time_res :
         Time resolution of data record i.e. 'hourly' or 'daily'
     rain_col_prefix :
@@ -141,44 +141,44 @@ def read_gdsr_data_from_file(
         Suffix for column name for target_gauge_col (set as None by default)
     suffix_only :
         Override to only include the suffix e.g. if the column name is the ID)
-    gdsr_header_rows :
+    gsdr_header_rows :
         Number of rows to skip in the header of the GSDR data (default=20)
 
     Returns
     -------
-    gdsr_data :
-        GDSR data as Pandas DataFrame
+    gsdr_data :
+        GSDR data as Pandas DataFrame
 
     """
     # 1. read in metadata of gauge
-    gdsr_metadata = read_gdsr_metadata(data_path)
+    gsdr_metadata = read_gsdr_metadata(data_path)
     if suffix_only:
         rain_col_name = f"{rain_col_suffix}"
     else:
-        rain_col_name = f"{gdsr_metadata['original_units']}"
+        rain_col_name = f"{gsdr_metadata['original_units']}"
         if rain_col_prefix:
             rain_col_name = f"{rain_col_prefix}_" + rain_col_name
         if rain_col_suffix:
             rain_col_name += f"_{rain_col_suffix}"
 
     # 2. read in gauge data
-    gdsr_data = pl.read_csv(
+    gsdr_data = pl.read_csv(
         data_path,
-        skip_rows=gdsr_header_rows,
+        skip_rows=gsdr_header_rows,
         schema_overrides={rain_col_name: pl.Float64},
     )
 
     # 3. add datetime column to data
-    gdsr_data = add_datetime_to_gdsr_data(
-        gdsr_data, gdsr_metadata, multiplying_factor=MULTIPLYING_FACTORS[raw_data_time_res]
+    gsdr_data = add_datetime_to_gsdr_data(
+        gsdr_data, gsdr_metadata, multiplying_factor=MULTIPLYING_FACTORS[raw_data_time_res]
     )
-    gdsr_data = data_utils.replace_missing_vals_with_nan(
-        gdsr_data, target_gauge_col=rain_col_name, missing_val=int(gdsr_metadata["no_data_value"])
+    gsdr_data = data_utils.replace_missing_vals_with_nan(
+        gsdr_data, target_gauge_col=rain_col_name, missing_val=int(gsdr_metadata["no_data_value"])
     )
 
     # 4. Select time and rain col
-    gdsr_data = gdsr_data.select(["time", rain_col_name])  # Reorder (to look nice)
-    return gdsr_data
+    gsdr_data = gsdr_data.select(["time", rain_col_name])  # Reorder (to look nice)
+    return gsdr_data
 
 
 def read_gpcc_data_from_zip(
@@ -260,51 +260,51 @@ def read_gpcc_data_from_zip(
     return gpcc_data
 
 
-def convert_gdsr_metadata_dates_to_datetime(gdsr_metadata: dict) -> dict:
+def convert_gsdr_metadata_dates_to_datetime(gsdr_metadata: dict) -> dict:
     """
-    Convert GDSR metadata date string column to datetime.
+    Convert GSDR metadata date string column to datetime.
 
     Parameters
     ----------
-    gdsr_metadata :
-        Metadata from GDSR file
+    gsdr_metadata :
+        Metadata from GSDR file
 
     Returns
     -------
-    gdsr_metadata : dict
-    Metadata from GDSR file with start and end date column
+    gsdr_metadata : dict
+    Metadata from GSDR file with start and end date column
 
     """
-    gdsr_metadata["start_datetime"] = datetime.datetime.strptime(gdsr_metadata["start_datetime"], "%Y%m%d%H")
-    gdsr_metadata["end_datetime"] = datetime.datetime.strptime(gdsr_metadata["end_datetime"], "%Y%m%d%H")
-    return gdsr_metadata
+    gsdr_metadata["start_datetime"] = datetime.datetime.strptime(gsdr_metadata["start_datetime"], "%Y%m%d%H")
+    gsdr_metadata["end_datetime"] = datetime.datetime.strptime(gsdr_metadata["end_datetime"], "%Y%m%d%H")
+    return gsdr_metadata
 
 
-def add_datetime_to_gdsr_data(
-    gdsr_data: pl.DataFrame, gdsr_metadata: dict, multiplying_factor: int | float
+def add_datetime_to_gsdr_data(
+    gsdr_data: pl.DataFrame, gsdr_metadata: dict, multiplying_factor: int | float
 ) -> pl.DataFrame:
     """
-    Add datetime column to GDSR gauge data using metadata from that gauge.
+    Add datetime column to GSDR gauge data using metadata from that gauge.
 
     NOTE: Could maybe extend so can find metadata if not provided?
 
     Parameters
     ----------
-    gdsr_data :
-        GDSR data
-    gdsr_metadata :
-        Metadata from GDSR file
+    gsdr_data :
+        GSDR data
+    gsdr_metadata :
+        Metadata from GSDR file
     multiplying_factor : int or float
         Factor to multiply the data by.
 
     Returns
     -------
-    gdsr_data
-        GDSR data with datetime column added
+    gsdr_data
+        GSDR data with datetime column added
 
     """
-    start_date = gdsr_metadata["start_datetime"]
-    end_date = gdsr_metadata["end_datetime"]
+    start_date = gsdr_metadata["start_datetime"]
+    end_date = gsdr_metadata["end_datetime"]
     assert isinstance(start_date, datetime.datetime), (
         "Please convert start_ and end_datetime to datetime.datetime objects"
     )
@@ -315,10 +315,10 @@ def add_datetime_to_gdsr_data(
         date_interval.append(start_date + datetime.timedelta(hours=i))
 
     # add time column
-    assert len(gdsr_data) == len(date_interval)
-    gdsr_data = gdsr_data.with_columns(time=pl.Series(date_interval))
+    assert len(gsdr_data) == len(date_interval)
+    gsdr_data = gsdr_data.with_columns(time=pl.Series(date_interval))
 
-    return gdsr_data
+    return gsdr_data
 
 
 def convert_data_hourly_to_daily(hourly_data: pl.DataFrame, rain_cols: List[str], hour_offset: int) -> pl.DataFrame:
@@ -383,32 +383,32 @@ def load_etccdi_data(etccdi_var: str, path_to_etccdi: str = None) -> xr.Dataset:
     return etccdi_data
 
 
-def load_gdsr_gauge_network_metadata(path_to_gdsr_dir: str, file_format: str = ".txt") -> pl.DataFrame:
+def load_gsdr_gauge_network_metadata(path_to_gsdr_dir: str, file_format: str = ".txt") -> pl.DataFrame:
     """
-    Load metadata from GDSR gauges from a directory.
+    Load metadata from GSDR gauges from a directory.
 
     Parameters
     ----------
-    path_to_gdsr_dir :
-        Path to directory with GDSR gauges
+    path_to_gsdr_dir :
+        Path to directory with GSDR gauges
     file_format :
         Format of file (default is .txt)
 
     Returns
     -------
     all_station_metadata :
-        All GDSR gauges metadata as one dataframe.
+        All GSDR gauges metadata as one dataframe.
 
     """
     # 1. Glob all metadata paths
-    if not os.path.isdir(path_to_gdsr_dir):
-        raise ValueError(f"Invalid GDSR metadata directory at {path_to_gdsr_dir}")
-    all_metadata_data_paths = glob.glob(f"{path_to_gdsr_dir}*{file_format}")
+    if not os.path.isdir(path_to_gsdr_dir):
+        raise ValueError(f"Invalid GSDR metadata directory at {path_to_gsdr_dir}")
+    all_metadata_data_paths = glob.glob(f"{path_to_gsdr_dir}*{file_format}")
 
-    # 2. Load all GDSR metadata from data
+    # 2. Load all GSDR metadata from data
     all_station_metadata_list = []
     for file in all_metadata_data_paths:
-        one_station_metadata = read_gdsr_metadata(data_path=file)
+        one_station_metadata = read_gsdr_metadata(data_path=file)
         all_station_metadata_list.append(one_station_metadata)
 
     # 3. Convert to pl.DataFrame
@@ -548,43 +548,43 @@ class GaugeNetworkReader(ABC):
         return all_neighbour_ids
 
 
-class GDSRNetworkReader(GaugeNetworkReader):
-    """GDSR rain gauge network reader."""
+class GSDRNetworkReader(GaugeNetworkReader):
+    """GSDR rain gauge network reader."""
 
-    def __init__(self, path_to_gdsr_dir: str, file_format: str = ".txt"):
+    def __init__(self, path_to_gsdr_dir: str, file_format: str = ".txt"):
         """Load network reader."""
-        self.path_to_gdsr_dir = path_to_gdsr_dir
+        self.path_to_gsdr_dir = path_to_gsdr_dir
         self.file_format = file_format
-        super().__init__(path_to_gdsr_dir)
+        super().__init__(path_to_gsdr_dir)
         self.data_paths = self._get_data_paths()
         self.metadata = self._add_paths_to_metadata()
         self.time_res = self.metadata["new_timestep"][0]
 
     def _load_metadata(self) -> pl.DataFrame:
         """
-        Load metadata from GDSR gauge metadata path.
+        Load metadata from GSDR gauge metadata path.
 
         Returns
         -------
         metadata :
-            Metadata of GDSR gauges.
+            Metadata of GSDR gauges.
 
         """
-        metadata = load_gdsr_gauge_network_metadata(self.path_to_gdsr_dir, self.file_format)
+        metadata = load_gsdr_gauge_network_metadata(self.path_to_gsdr_dir, self.file_format)
         return metadata
 
     def _get_data_paths(self) -> dict:
         """
-        Get paths to gauge network of GDSR gauges.
+        Get paths to gauge network of GSDR gauges.
 
         Returns
         -------
         gauge_paths :
-            Dataframe of all GDSR gauges rain record.
+            Dataframe of all GSDR gauges rain record.
 
         """
         gauge_paths = get_paths_using_gauge_ids(
-            self.metadata["station_id"], self.path_to_gdsr_dir, file_format=self.file_format
+            self.metadata["station_id"], self.path_to_gsdr_dir, file_format=self.file_format
         )
         return gauge_paths
 
@@ -598,10 +598,10 @@ class GDSRNetworkReader(GaugeNetworkReader):
         rain_col_prefix: str,
         data_paths: List[str] | np.ndarray[str],
         suffix_only: bool = False,
-        gdsr_header_rows: int = 20,
+        gsdr_header_rows: int = 20,
     ) -> pl.DataFrame:
         """
-        Load GDSR network data based on file paths.
+        Load GSDR network data based on file paths.
 
         Parameters
         ----------
@@ -611,28 +611,28 @@ class GDSRNetworkReader(GaugeNetworkReader):
             Prefix for rain column name (default is 'rain')
         suffix_only :
             Override to only include the suffix e.g. if the column name is the ID)
-        gdsr_header_rows :
+        gsdr_header_rows :
             Number of rows to skip in the header of the GSDR data (default=20)
 
         Returns
         -------
         network_data :
-            Dataframe of GDSR gauges.
+            Dataframe of GSDR gauges.
 
         """
         for ind, path in enumerate(data_paths):
             # 1. get gauge_id name
-            gdsr_file_name = path.split("/")[-1]
-            gdsr_name = gdsr_file_name.split(".")[0]
+            gsdr_file_name = path.split("/")[-1]
+            gsdr_name = gsdr_file_name.split(".")[0]
 
             # 2. Read in one gauge
-            one_gauge = read_gdsr_data_from_file(
+            one_gauge = read_gsdr_data_from_file(
                 data_path=path,
-                raw_data_time_res=GDSR_TIME_RES_CONVERSION[self.time_res],
+                raw_data_time_res=GSDR_TIME_RES_CONVERSION[self.time_res],
                 rain_col_prefix=rain_col_prefix,
-                rain_col_suffix=gdsr_name,
+                rain_col_suffix=gsdr_name,
                 suffix_only=suffix_only,
-                gdsr_header_rows=gdsr_header_rows,
+                gsdr_header_rows=gsdr_header_rows,
             )
 
             # 3. Join data together
@@ -679,7 +679,7 @@ class GPCCNetworkReader(GaugeNetworkReader):
         Returns
         -------
         gauge_paths :
-            Dataframe of all GDSR gauges rain record.
+            Dataframe of all GSDR gauges rain record.
 
         """
         gauge_paths = get_paths_using_gauge_ids(

{rainfallqc-0.2.4 → rainfallqc-0.2.5}/src/rainfallqc/utils/data_utils.py

@@ -582,8 +582,8 @@ def replace_missing_vals_with_nan(
 
     Returns
     -------
-    gdsr_data
-        GDSR data with missing values replaced
+    gsdr_data
+        GSDR data with missing values replaced
 
     """
     if missing_val is None: