loone-data-prep 1.2.4__tar.gz → 1.3.1__tar.gz

{loone_data_prep-1.2.4 → loone_data_prep-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loone_data_prep
-Version: 1.2.4
+Version: 1.3.1
 Summary: Prepare data to run the LOONE model.
 Author-email: Osama Tarabih <osamatarabih@usf.edu>
 Maintainer-email: Michael Souffront <msouffront@aquaveo.com>, James Dolinar <jdolinar@aquaveo.com>
@@ -18,7 +18,6 @@ License: BSD-3-Clause License
         
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: rpy2
 Requires-Dist: retry
 Requires-Dist: numpy<2
 Requires-Dist: pandas
@@ -30,6 +29,7 @@ Requires-Dist: requests_cache
 Requires-Dist: retry-requests
 Requires-Dist: eccodes==2.41.0
 Requires-Dist: xarray==2025.4.0
+Requires-Dist: dbhydro-py
 Dynamic: license-file
 
 LOONE_DATA_PREP
@@ -40,11 +40,6 @@ Prepare data for the LOONE water quality model.
 Line to the LOONE model: [https://pypi.org/project/loone](https://pypi.org/project/loone)
 Link to LOONE model repository: [https://github.com/Aquaveo/LOONE](https://github.com/Aquaveo/LOONE)
 
-## Prerequisites:
-
-* R ([https://www.r-project.org/](https://www.r-project.org/))
-* R packages: dbhydroR, rio, dplyr
-
 ## Installation:
 
 ```bash
@@ -103,7 +98,6 @@ dbkeys = get_dbkeys(
     stat="MEAN",
     recorder="CR10",
     freq="DA",
-    detail_level="dbkey"
 )
 
 # Get water level data

{loone_data_prep-1.2.4 → loone_data_prep-1.3.1}/README.md

@@ -6,11 +6,6 @@ Prepare data for the LOONE water quality model.
 Line to the LOONE model: [https://pypi.org/project/loone](https://pypi.org/project/loone)
 Link to LOONE model repository: [https://github.com/Aquaveo/LOONE](https://github.com/Aquaveo/LOONE)
 
-## Prerequisites:
-
-* R ([https://www.r-project.org/](https://www.r-project.org/))
-* R packages: dbhydroR, rio, dplyr
-
 ## Installation:
 
 ```bash
@@ -69,7 +64,6 @@ dbkeys = get_dbkeys(
     stat="MEAN",
     recorder="CR10",
     freq="DA",
-    detail_level="dbkey"
 )
 
 # Get water level data

{loone_data_prep-1.2.4 → loone_data_prep-1.3.1}/loone_data_prep/GEOGLOWS_LOONE_DATA_PREP.py

@@ -15,7 +15,7 @@ from loone_data_prep.utils import stg2sto, stg2ar
 import datetime
 
 START_DATE = datetime.datetime.now()
-END_DATE = START_DATE + datetime.timedelta(days=15)
+END_DATE = START_DATE + datetime.timedelta(days=14)
 
 M3_Yr = 2008
 M3_M = 1
@@ -373,8 +373,8 @@ def main(input_dir: str, output_dir: str, ensemble_number: str) -> None:  # , hi
     C44RO_df['C44RO_cmd'] = C44RO
     C43RO_df['C43RO'] = C43RO_df['C43RO_cmd']/(0.0283168466 * 86400)
     C44RO_df['C44RO'] = C44RO_df['C44RO_cmd']/(0.0283168466 * 86400)
-    C43RO_df.to_csv(f'{output_dir}/C43RO_{ensemble_number}.csv', index=False)
-    C44RO_df.to_csv(f'{output_dir}/C44RO_{ensemble_number}.csv', index=False)
+    C43RO_df.to_csv(f'{output_dir}/C43RO_{ensemble_number}.csv')
+    C44RO_df.to_csv(f'{output_dir}/C44RO_{ensemble_number}.csv')
     C43RO_df.index = pd.to_datetime(C43RO_df["date"])
     C43RO_df = C43RO_df.drop(columns="date")
 
@@ -384,13 +384,13 @@ def main(input_dir: str, output_dir: str, ensemble_number: str) -> None:  # , hi
     C43Mon = C43RO_df.resample('ME').mean()
     C44Mon = C44RO_df.resample('ME').mean()
 
-    C43Mon.to_csv(f'{output_dir}/C43RO_Monthly_{ensemble_number}.csv', index=False)
-    C44Mon.to_csv(f'{output_dir}/C44RO_Monthly_{ensemble_number}.csv', index=False)
+    C43Mon.to_csv(f'{output_dir}/C43RO_Monthly_{ensemble_number}.csv')
+    C44Mon.to_csv(f'{output_dir}/C44RO_Monthly_{ensemble_number}.csv')
     Basin_RO = pd.DataFrame(C44Mon.index, columns=['date'])
     # Basin_RO['SLTRIB'] = SLTRIBMon['SLTRIB_cfs'].values * 1.9835  # cfs to acft
     Basin_RO['C44RO'] = C44Mon['C44RO'].values * 86400
     Basin_RO['C43RO'] = C43Mon['C43RO'].values * 86400
-    Basin_RO.to_csv(f'{output_dir}/Basin_RO_inputs_{ensemble_number}.csv', index=False)
+    Basin_RO.to_csv(f'{output_dir}/Basin_RO_inputs_{ensemble_number}.csv')
 
     # # Get monthly C43RO and C44RO from historical run
     # shutil.copyfile(os.path.join(historical_files_src, "C43RO_Monthly.csv"), os.path.join(output_dir, 'C43RO_Monthly.csv'))
@@ -461,16 +461,47 @@ def main(input_dir: str, output_dir: str, ensemble_number: str) -> None:  # , hi
     LOWS.to_csv(f"{output_dir}/LOWS_predicted.csv")
 
     # # RFVol acft
-    # # Create File (RF_Volume)
-    # RFVol = pd.DataFrame(RF_data["date"], columns=["date"])
-    # RFVol["RFVol_acft"] = (RF_data["average_rainfall"].values / 12) * LO_Stg_Sto_SA_df["SA_acres"].values
-    # RFVol.to_csv(f"{output_dir}/RFVol_LORS_20082023.csv", index=False)
-
-    # # ETVol acft
-    # # Create File (ETVol)
-    # ETVol = pd.DataFrame(ET_data["date"], columns=["date"])
-    # ETVol["ETVol_acft"] = (ET_data["average_ETPI"].values / 12) * LO_Stg_Sto_SA_df["SA_acres"].values
-    # ETVol.to_csv(f"{output_dir}/ETVol_LORS_20082023.csv", index=False)
+    RF_data = pd.read_csv(f'{input_dir}/LAKE_RAINFALL_DATA_FORECAST.csv')
+    # RF_data_copy = RF_data.copy()
+    # LO_Stg_Sto_SA_df_copy = LO_Stg_Sto_SA_df.copy()
+    RF_data['date'] = pd.to_datetime(RF_data['date'])
+    # LO_Stg_Sto_SA_df_copy['date'] = pd.to_datetime(LO_Stg_Sto_SA_df_copy['date'])
+    # LO_Stg_Sto_SA_df_copy.index.name = None
+
+
+    # merged_rf_sa = pd.merge(RF_data_copy[['date', 'average_rainfall']], 
+    #                         LO_Stg_Sto_SA_df_copy[['date', 'SA_acres']], 
+    #                         on='date', how='inner')
+    #I am just using the most recent SA_acres value for all forecast dates since we do not have forecasted surface area
+    RFVol = pd.DataFrame(RF_data['date'], columns=['date'])
+    RFVol['RFVol_acft'] = (RF_data['average_rainfall'].values/12) * LO_Stg_Sto_SA_df["SA_acres"].iloc[-1]
+
+    date_reference = RFVol['date'].iloc[0]
+    date_inserts = [date_reference - datetime.timedelta(days=2), date_reference - datetime.timedelta(days=1)]
+    df_insert = pd.DataFrame(data={'date': date_inserts, 'RFVol_acft': [0.0, 0.0]})
+    RFVol = pd.concat([df_insert, RFVol])
+    RFVol.to_csv(f'{output_dir}/RFVol_Forecast.csv', index=False)
+    
+        # ETVol acft
+    # Create File (ETVol)
+    # Merge the DataFrames on date to ensure matching rows
+    ET_data = pd.read_csv(f'{input_dir}/LOONE_AVERAGE_ETPI_DATA_FORECAST.csv')
+    # ET_data_copy = ET_data.copy()
+    # LO_Stg_Sto_SA_df_copy = LO_Stg_Sto_SA_df.copy()
+    ET_data['date'] = pd.to_datetime(ET_data['date'])
+    # LO_Stg_Sto_SA_df_copy['date'] = pd.to_datetime(LO_Stg_Sto_SA_df_copy['date'])
+    # merged_et_sa = pd.merge(ET_data_copy[['date', 'average_ETPI']],
+    #                         LO_Stg_Sto_SA_df_copy[['date', 'SA_acres']], 
+    #                         on='date', how='inner')
+
+    ETVol = pd.DataFrame(ET_data['date'], columns=['date'])
+    ETVol['ETVol_acft'] = (ET_data['average_ETPI'].values/12) * LO_Stg_Sto_SA_df["SA_acres"].iloc[-1]
+    date_reference = ETVol['date'].iloc[0]
+    date_inserts = [date_reference - datetime.timedelta(days=2), date_reference - datetime.timedelta(days=1)]
+    df_insert = pd.DataFrame(data={'date': date_inserts, 'ETVol_acft': [0.0, 0.0]})
+    ETVol = pd.concat([df_insert, ETVol])
+    ETVol.to_csv(f'{output_dir}/ETVol_forecast.csv', index=False)
+
 
     # # WCA Stages
     # # Create File (WCA_Stages_Inputs)

{loone_data_prep-1.2.4 → loone_data_prep-1.3.1}/loone_data_prep/LOONE_DATA_PREP.py

@@ -351,7 +351,6 @@ def main(input_dir: str, output_dir: str) -> None:
     S65E.index = pd.to_datetime(S65E.index, unit='ns')
     S65E_Weekly = S65E.resample('W-FRI').mean()
     # PI
-    # TODO
     # This is prepared manually
     # Weekly data is downloaded from https://www.ncei.noaa.gov/access/monitoring/weekly-palmers/time-series/0804
     # State:Florida Division:4.South Central

loone_data_prep-1.3.1/loone_data_prep/dbhydro_insights.py

@@ -0,0 +1,195 @@
+"""
+Utilities for interacting with the DBHYDRO Insights database services.
+
+This module provides functions for fetching data from endpoints used
+by the South Florida Water Management District's DBHYDRO Insights app.
+"""
+
+from datetime import datetime
+import requests
+from typing import Literal, Tuple
+
+
+def get_dbhydro_station_metadata(station_id: str) -> dict | None:
+    """
+    Fetches metadata for a specific station from the DBHYDRO_SiteStation service.
+    
+    Args:
+        station_id (str): The ID of the station for which to fetch metadata. Examples: 'FISHP', 'L OKEE', etc.
+    
+    Returns:
+        dict: A dictionary containing the metadata of the station, or None if the request fails.
+    """
+    # Build the request URL with the provided station ID
+    request_url = 'https://geoweb.sfwmd.gov/agsext2/rest/services/MonitoringLocations/DBHYDRO_SiteStation/MapServer/4/query'
+    
+    params = {
+        'f': 'json',
+        'outFields': '*',
+        'spatialRel': 'esriSpatialRelIntersects',
+        'where': f"(STATION = '{station_id}')"
+    }
+    
+    # Send the GET request to the specified URL with the parameters
+    try:
+        response = requests.get(request_url, params=params)
+    except requests.exceptions.RequestException:
+        return None
+    
+    # Successful Request
+    if response.status_code == 200:
+        # Parse the JSON response
+        json = response.json()
+        
+        # No data given back for given station ID
+        if not json['features']:
+            return None
+        
+        # Data given back, return the JSON response
+        return json
+    
+    # Failure
+    return None
+
+
+def get_dbhydro_continuous_timeseries_metadata(
+    station_ids: list[str],
+    categories: list[str] | None = ['ALL'],
+    parameters: list[str] | None = ['ALL'],
+    statistics: list[str] | None = ['ALL'],
+    recorders: list[str] | None = ['ALL'],
+    frequencies: list[str] | None = ['ALL']
+) -> dict | None:
+    """Fetches metadata for continuous time series data from the DBHYDRO Insights service.
+    
+    Args:
+        station_ids (list[str]): List of station IDs to query.
+        categories (list[str] | None): List of categories to filter by. Defaults to ['ALL'].
+        parameters (list[str] | None): List of parameters to filter by. Defaults to ['ALL'].
+        statistics (list[str] | None): List of statistics to filter by. Defaults to ['ALL'].
+        recorders (list[str] | None): List of recorders to filter by. Defaults to ['ALL'].
+        frequencies (list[str] | None): List of frequencies to filter by. Defaults to ['ALL'].
+
+    Returns:
+        dict | None: The JSON response from the API if successful, otherwise None.
+    
+    Raises:
+        Exception: If the request fails.
+    """
+    # Build the request URL
+    request_url = 'https://insightsdata.api.sfwmd.gov/v1/insights-data/cont/ts'
+    
+    # Build the locations list
+    locations = []
+    
+    for station_id in station_ids:
+        # Build the location dictionary for this station_id
+        location = {
+            'name': station_id,
+            'type': 'STATION',
+        }
+        
+        # Add location to the locations list
+        locations.append(location)
+    
+    # Build the data payload
+    data = {
+        'query': {
+            'locations': locations,
+            'parameters': parameters,
+            'category': categories,
+            'statistic': statistics,
+            'recorder': recorders,
+            'frequency': frequencies,
+            'dbkeys': ['ALL'],
+        }
+    }
+    
+    # Send the POST request to the specified URL with the parameters
+    response = requests.post(request_url, json=data)
+
+    # Successful Request
+    if response.status_code == 200:
+        # Parse the JSON response
+        json = response.json()
+        
+        # No data given back for given station ID
+        if not json['results']:
+            return None
+        
+        # Data given back, return the JSON response
+        return json
+    
+    # Failure
+    raise Exception(f"Request failed with status code {response.status_code}: {response.text}")
+
+
+def get_dbhydro_water_quality_metadata(stations: list[Tuple[str,Literal['SITE', 'STATION']]], test_numbers: list[int]) -> dict | None:
+    """Fetches metadata for water quality data from the DBHYDRO Insights service.
+    
+    Args:
+        stations (list[Tuple[str, Literal['SITE', 'STATION']]]): List of tuples containing station names and station types ('SITE' or 'STATION') to get water quality metadata for.
+        test_numbers (list[int]): List of test numbers to get data for. Test numbers map to parameters. Example: 25 maps to 'PHOSPHATE, TOTAL AS P'.
+    
+    Returns:
+        dict | None: The JSON response from the API if successful, otherwise None.
+    
+    Raises:
+        Exception: If the request fails.
+    """
+    # Build the request URL
+    request_url = 'https://insightsdata.api.sfwmd.gov/v1/insights-data/chem/ts'
+    
+    # Build the locations list
+    locations = []
+    
+    for station in stations:
+        # Build the location dictionary for this station/site
+        location = {
+            'name': station[0],
+            'type': station[1],
+        }
+        
+        # Add location to the locations list
+        locations.append(location)
+    
+    # Build the query parameters
+    query_parameters = {
+        'offset': 0,
+        'limit': 1000,
+        'sort': 'project,location,parameterDesc,matrix,method',
+        'startDate': '19000101',
+        'endDate': datetime.now().strftime("%Y%m%d"),
+        'period': '',
+    }
+    
+    # Build the data payload
+    payload = {
+        'query': {
+            'locations': locations,
+            'matrices': ['ALL'],
+            'methods': ['ALL'],
+            'paramGroups': ['ALL'],
+            'parameters': [str(num) for num in test_numbers],
+            'projects': ['ALL'],
+            'sampleTypes': ['ALL'],
+        }
+    }
+    
+    # Send the POST request to the specified URL with the parameters
+    response = requests.post(request_url, params=query_parameters, json=payload)
+
+    # Successful Request
+    if response.status_code == 200:
+        # Parse the JSON response
+        json = response.json()
+        
+        # No data given back for given station ID
+        if not json['results']:
+            return None
+        
+        # Data given back, return the JSON response
+        return json
+    
+    # Failure
+    raise Exception(f"Request failed with status code {response.status_code}: {response.text}")

loone_data_prep-1.3.1/loone_data_prep/flow_data/S65E_total.py

@@ -0,0 +1,89 @@
+import sys
+from retry import retry
+import pandas as pd
+from loone_data_prep.utils import df_replace_missing_with_nan, get_dbhydro_api
+
+
+@retry(Exception, tries=5, delay=15, max_delay=60, backoff=2)
+def get(
+    workspace, 
+    date_min: str = "1972-01-01", 
+    date_max: str = "2023-06-30"
+) -> None:
+    """Retrieve total flow data for S65E structure (S65E_S + S65EX1_S) and save to CSV.
+    
+    Args:
+        workspace (str): Path to workspace where data will be downloaded.
+        date_min (str): Minimum date for data retrieval in 'YYYY-MM-DD' format.
+        date_max (str): Maximum date for data retrieval in 'YYYY-MM-DD' format.
+    """
+    # Get a DbHydroApi instance
+    api = get_dbhydro_api()
+    
+    # S65E_S
+    s65e_s = api.get_daily_data(['91656'], 'id', date_min, date_max, 'NGVD29', False)
+    
+    if not s65e_s.has_data():
+        return
+    
+    df_s65e_s = s65e_s.to_dataframe(True)
+    df_s65e_s = df_replace_missing_with_nan(df_s65e_s)                                              # Replace flagged 0 values and -99999.0 with NaN
+    df_s65e_s.reset_index(inplace=True)                                                             # Reset index so datetime is a column
+    df_s65e_s['value'] = df_s65e_s['value'] * (0.0283168466 * 86400)                                # Convert flow from cfs to cmd
+    df_s65e_s = df_s65e_s[['datetime', 'value']].copy()                                             # Grab only the columns we need
+    df_s65e_s.rename(columns={'datetime': 'date', 'value': f'S65E_S_FLOW_cfs'}, inplace=True)       # Rename columns to expected names
+    
+    # S65EX1_S
+    s65ex1_s = api.get_daily_data(['AL760'], 'id', date_min, date_max, 'NGVD29', False)
+    
+    if not s65ex1_s.has_data():
+        return
+    
+    df_s65ex1_s = s65ex1_s.to_dataframe(True)
+    df_s65ex1_s = df_replace_missing_with_nan(df_s65ex1_s)                                          # Replace flagged 0 values and -99999.0 with NaN
+    df_s65ex1_s.reset_index(inplace=True)                                                           # Reset index so datetime is a column
+    df_s65ex1_s['value'] = df_s65ex1_s['value'] * (0.0283168466 * 86400)                            # Convert flow from cfs to cmd
+    df_s65ex1_s = df_s65ex1_s[['datetime', 'value']].copy()                                         # Grab only the columns we need
+    df_s65ex1_s.rename(columns={'datetime': 'date', 'value': f'S65EX1_S_FLOW_cfs'}, inplace=True)   # Rename columns to expected names
+    
+    # Combine the data from both stations into a single dataframe
+    df = pd.merge(df_s65e_s, df_s65ex1_s, on='date', how='outer', suffixes=('_S65E_S', '_S65EX1_S'))
+    
+    # Reformat the data to the expected layout
+    df = _reformat_s65e_total_df(df)
+    
+    # Write the data to a file
+    df.to_csv(f"{workspace}/S65E_total.csv")
+
+
+def _reformat_s65e_total_file(workspace: str):
+    # Read in the data
+    df = pd.read_csv(f"{workspace}/S65E_total.csv")
+    
+    # Reformat the data
+    df = _reformat_s65e_total_df(df)
+    
+    # Write the updated data back to the file
+    df.to_csv(f"{workspace}/S65E_total.csv")
+
+
+def _reformat_s65e_total_df(df: pd.DataFrame) -> pd.DataFrame:
+    # Convert date column to datetime
+    df['date'] = pd.to_datetime(df['date'], format='%d-%b-%Y')
+    
+    # Sort the data by date
+    df.sort_values('date', inplace=True)
+    
+    # Renumber the index
+    df.reset_index(drop=True, inplace=True)
+    
+    # Drop rows that are missing all their values
+    df.dropna(how='all', inplace=True)
+    
+    # Return the reformatted dataframe
+    return df
+
+
+if __name__ == "__main__":
+    workspace = sys.argv[1].rstrip("/")
+    get(workspace)

{loone_data_prep-1.2.4 → loone_data_prep-1.3.1}/loone_data_prep/flow_data/forecast_bias_correction.py

@@ -38,7 +38,7 @@ def get_bias_corrected_data(
     # Prepare the observed data by filling NaN values with the 10yr average
     prepared_od = prep_observed_data(observed_data)
     historical_data = geoglows.data.retro_daily(reach_id)
-    # Get the historical simulation data for the given reach ID - TODO: Do we for sure want to cache the historical data?
+    # Get the historical simulation data for the given reach ID
     # I am reading the observed data that we queried earlier instead of caching it
     # historical_data = None
 

{loone_data_prep-1.2.4 → loone_data_prep-1.3.1}/loone_data_prep/flow_data/get_forecast_flows.py

@@ -1,11 +1,8 @@
 import os
 import sys
 import pandas as pd
-import rpy2.robjects as ro
-from rpy2.robjects import pandas2ri
 import geoglows
 import datetime
-from loone_data_prep.utils import get_dbkeys
 from loone_data_prep.flow_data.forecast_bias_correction import (
     get_bias_corrected_data,
 )
@@ -63,51 +60,6 @@ FORECAST_DATE = (datetime.datetime.now()).strftime("%Y%m%d")
 GEOGLOWS_ENDPOINT = "https://geoglows.ecmwf.int/api/"
 
 
-def get_stations_latitude_longitude(station_ids: list[str]):
-    """Gets the latitudes and longitudes of the given stations.
-
-    Args:
-        station_ids (list[str]): The ids of the stations to get the
-            latitudes/longitudes of
-
-    Returns:
-        (dict[str, tuple[numpy.float64, numpy.float64]]): A dictionary of
-            format dict<station_id:(latitude,longitude)>
-
-    If a station's latitude/longitude fails to download then its station_id
-        won't be a key in the returned dictionary.
-    """
-    # The dict that holds the data that gets returned
-    station_data = {}
-
-    # Get the station/dbkey data
-    r_dataframe = get_dbkeys(
-        station_ids=station_ids,
-        category="SW",
-        param="",
-        stat="",
-        recorder="",
-        detail_level="full",
-    )
-
-    # Convert the r dataframe to a pandas dataframe
-    with (ro.default_converter + pandas2ri.converter).context():
-        pd_dataframe = ro.conversion.get_conversion().rpy2py(r_dataframe)
-
-    # Filter out extra rows for each station from the dataframe
-    pd_dataframe.drop_duplicates(subset="Station", keep="first", inplace=True)
-
-    # Get latitude/longitude of each station
-    for index in pd_dataframe.index:
-        station = pd_dataframe["Station"][index]
-        latitude = pd_dataframe["Latitude"][index]
-        longitude = pd_dataframe["Longitude"][index]
-
-        station_data[station] = latitude, longitude
-
-    return station_data
-
-
 def get_reach_id(latitude: float, longitude: float):
     """Gets the reach id for the given latitude/longitude.
 
@@ -273,70 +225,32 @@ def _format_stats_DataFrame(dataframe: pd.core.frame.DataFrame):
     dataframe.index = dataframe.index.normalize()
 
     # Convert m^3/s data to m^3/h
-    dataframe = dataframe.transform(lambda x: x * SECONDS_IN_HOUR)
+    dataframe = dataframe * SECONDS_IN_HOUR
 
     # Make negative values 0
     dataframe.clip(0, inplace=True)
 
-    # Max Column (Max)
-    column_max = dataframe[["flow_max"]].copy()
-    column_max = column_max.groupby([column_max.index]).max()
-
-    # 75th Percentile Column (Average)
-    column_75percentile = dataframe[["flow_75p"]].copy()
-    column_75percentile = column_75percentile.groupby(
-        [column_75percentile.index]
-    ).mean()
-
-    # Average Column (Weighted Average)
-    column_average = dataframe[["flow_avg"]].copy()
-    column_average.transform(lambda x: x / 8)
-    column_average = column_average.groupby([column_average.index]).sum()
-
-    # 25th Percentile Column (Average)
-    column_25percentile = dataframe[["flow_25p"]].copy()
-    column_25percentile = column_25percentile.groupby(
-        [column_25percentile.index]
-    ).mean()
-
-    # Min Column (Min)
-    column_min = dataframe[["flow_min"]].copy()
-    column_min = column_min.groupby([column_min.index]).min()
-
-    # Convert values in each column from m^3/h to m^3/d
-    column_max = column_max.transform(lambda x: x * HOURS_IN_DAY)
-    column_75percentile = column_75percentile.transform(
-        lambda x: x * HOURS_IN_DAY
-    )
-    column_average = column_average.transform(lambda x: x * HOURS_IN_DAY)
-    column_25percentile = column_25percentile.transform(
-        lambda x: x * HOURS_IN_DAY
+    grouped = dataframe.groupby(dataframe.index).mean()
+    # Convert from m^3/h → m^3/d
+    grouped = grouped * HOURS_IN_DAY
+
+    # Rename columns
+    grouped = grouped.rename(
+        columns={
+            "flow_max": "flow_max_m^3/d",
+            "flow_75p": "flow_75%_m^3/d",
+            "flow_avg": "flow_avg_m^3/d",
+            "flow_med": "flow_med_m^3/d",
+            "flow_25p": "flow_25%_m^3/d",
+            "flow_min": "flow_min_m^3/d",
+        }
     )
-    column_min = column_min.transform(lambda x: x * HOURS_IN_DAY)
-
-    # Append modified columns into one pandas DataFrame
-    dataframe_result = pd.DataFrame()
-    dataframe_result.index = dataframe.groupby([dataframe.index]).mean().index
-    dataframe_result["flow_max_m^3/d"] = column_max["flow_max"].tolist()
-    dataframe_result["flow_75%_m^3/d"] = column_75percentile[
-        "flow_75p"
-    ].tolist()
-    dataframe_result["flow_avg_m^3/d"] = column_average[
-        "flow_avg"
-    ].tolist()
-    dataframe_result["flow_25%_m^3/d"] = column_25percentile[
-        "flow_25p"
-    ].tolist()
-    dataframe_result["flow_min_m^3/d"] = column_min["flow_min"].tolist()
 
-    # Format datetimes to just dates
-    dataframe_result.index = dataframe_result.index.strftime("%Y-%m-%d")
+    # Format index as date string and rename
+    grouped.index = grouped.index.strftime("%Y-%m-%d")
+    grouped.index.name = "date"
 
-    # Rename index from datetimes to date
-    dataframe_result.rename_axis("date", inplace=True)
-
-    # Return resulting DataFrame
-    return dataframe_result
+    return grouped
 
 
 def main(