loone-data-prep 1.2.4__py3-none-any.whl → 1.3.1__py3-none-any.whl

loone_data_prep/utils.py

@@ -5,17 +5,14 @@ import math
 from glob import glob
 from calendar import monthrange
 import traceback
+from typing import Literal, Tuple
 import numpy as np
 import pandas as pd
 from retry import retry
 from scipy.optimize import fsolve
 from scipy import interpolate
-from rpy2.robjects import r
-from rpy2.robjects.vectors import (
-    StrVector as rpy2StrVector,
-    DataFrame as rpy2DataFrame,
-)
-from rpy2.rinterface_lib.embedded import RRuntimeError
+from dbhydro_py import DbHydroApi
+from loone_data_prep.dbhydro_insights import get_dbhydro_station_metadata, get_dbhydro_continuous_timeseries_metadata, get_dbhydro_water_quality_metadata
 
 
 DEFAULT_STATION_IDS = ["L001", "L005", "L006", "LZ40"]
@@ -224,7 +221,7 @@ DEFAULT_EXPFUNC_NITROGEN_CONSTANTS = {
     "S135_P": {"a": 3.09890183766129, "b": 0.657896838486496},
 }
 
-@retry(RRuntimeError, tries=5, delay=15, max_delay=60, backoff=2)
+@retry(Exception, tries=5, delay=15, max_delay=60, backoff=2)
 def get_dbkeys(
     station_ids: list,
     category: str,
@@ -232,9 +229,8 @@ def get_dbkeys(
     stat: str,
     recorder: str,
     freq: str = "DA",
-    detail_level: str = "dbkey",
     *args: str,
-) -> rpy2StrVector | rpy2DataFrame:
+) -> list[str]:
     """Get dbkeys. See DBHydroR documentation for more information:
     https://cran.r-project.org/web/packages/dbhydroR/dbhydroR.pdf
 
@@ -245,27 +241,68 @@ def get_dbkeys(
         stat (str): Statistic of data to retrieve.
         recorder (str): Recorder of data to retrieve.
         freq (str, optional): Frequency of data to retrieve. Defaults to "DA".
-        detail_level (str, optional): Detail level of data to retrieve. Defaults to "dbkey". Options are "dbkey",
-            "summary", or "full".
 
     Returns:
-        rpy2StrVector | rpy2DataFrame: dbkeys info at the specified detail level.
+        list[str]: dbkeys info for the specified parameters.
     """
+    # Retrieve the metadata for the specified parameters
+    metadata = get_dbhydro_continuous_timeseries_metadata(station_ids, [category], [param], [stat], [recorder], [freq])
+    
+    # A set to hold the dbkeys to avoid duplicates
+    dbkeys = set()
+    
+    # No data returned from API
+    if metadata is None:
+        return list(dbkeys)
+    
+    # Get the dbkeys from the metadata
+    for result in metadata['results']:
+        dbkeys.add(result['timeseriesId'])
+    
+    # Return the dbkeys as a list
+    return list(dbkeys)
 
-    station_ids_str = '"' + '", "'.join(station_ids) + '"'
 
-    dbkeys = r(
-        f"""
-        library(dbhydroR)
+def get_stations_latitude_longitude(station_ids: list[str]):
+    """Gets the latitudes and longitudes of the given stations.
 
-        station_ids <- c({station_ids_str})
-        dbkeys <- get_dbkey(stationid = station_ids,  category = "{category}", param = "{param}", stat = "{stat}", recorder="{recorder}", freq = "{freq}", detail.level = "{detail_level}")
-        print(dbkeys)
-        return(dbkeys)
-        """  # noqa: E501
-    )
+    Args:
+        station_ids (list[str]): The ids of the stations to get the
+            latitudes/longitudes of. Example: ['L OKEE', 'FISHP']
 
-    return dbkeys
+    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.
+    """
+    # Dictionary to hold the latitude/longitude of each station
+    station_data = {}
+    
+    # Get the latitude and longitude for each station
+    for station_id in station_ids:
+        # Retrieve the current station's metadata
+        station_metadata = get_dbhydro_station_metadata(station_id)
+        
+        # Check if the metadata was successfully retrieved
+        if station_metadata is None:
+            print(f'Failed to get latitude/longitude for station {station_id} - No data given back from API')
+            continue
+        
+        # Extract the latitude and longitude from the metadata
+        try:
+            latitude = station_metadata['features'][0]['attributes']['LAT']
+            longitude = station_metadata['features'][0]['attributes']['LONG']
+        except KeyError:
+            print(f'Failed to get latitude/longitude for station {station_id} - Unexpected response structure from API')
+            continue
+        
+        # Add the latitude and longitude to the dictionary
+        station_data[station_id] = latitude, longitude
+    
+    # Return the dictionary of station latitudes and longitudes
+    return station_data
 
 
 def data_interpolations(
@@ -916,9 +953,17 @@ def find_last_date_in_csv(workspace: str, file_name: str) -> str:
 
     # Helper Functions
     def is_valid_date(date_string):
+        # Check for date without time part
         try:
             datetime.datetime.strptime(date_string, "%Y-%m-%d")
             return True
+        except ValueError:
+            pass
+        
+        # Check for date with time part
+        try:
+            datetime.datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
+            return True
         except ValueError:
             return False
 
@@ -955,23 +1000,69 @@ def find_last_date_in_csv(workspace: str, file_name: str) -> str:
         return None
 
 
-def dbhydro_data_is_latest(date_latest: str):
+def dbhydro_data_is_latest(date_latest: str, dbkey: str | None = None) -> bool:
     """
     Checks whether the given date is the most recent date possible to get data from dbhydro.
     Can be used to check whether dbhydro data is up-to-date.
 
     Args:
         date_latest (str): The date of the most recent data of the dbhydro data you have
+        dbkey (str | None, optional): The dbkey of the data you are checking. Defaults to None.
 
     Returns:
         bool: True if the date_latest is the most recent date possible to get data from dbhydro, False otherwise
     """
-    date_latest_object = datetime.datetime.strptime(
-        date_latest, "%Y-%m-%d"
-    ).date()
-    return date_latest_object == (
-        datetime.datetime.now().date() - datetime.timedelta(days=1)
-    )
+    # Convert date_latest to a date object
+    date_latest_object = pd.to_datetime(date_latest).date()
+    
+    # No dbkey provided
+    if dbkey is None:
+        # Assume latest data available is yesterday
+        return date_latest_object == (datetime.datetime.now().date() - datetime.timedelta(days=1))
+    
+    # Get dbhydro api
+    dbhydro_api = get_dbhydro_api()
+    
+    # Retrieve the last date available from dbhydro for the given dbkey
+    data = dbhydro_api.get_daily_data([dbkey], 'id', '1900-01-01', '1900-01-02', 'NGVD29', False)
+    last_date = data.time_series[0].period_of_record.por_last_date
+    
+    # Use date part only (exclude time)
+    last_date = last_date.split("T")[0]
+    
+    # Convert last_date to a date object
+    last_date_object = datetime.datetime.strptime(last_date, "%Y-%m-%d").date()
+    
+    # Compare given date to last date from dbhydro
+    return date_latest_object >= last_date_object
+
+
+def dbhydro_water_quality_data_is_latest(date_latest: str, station: str, station_type: Literal['SITE', 'STATION'], test_number: int) -> bool:
+    """
+    Checks whether the given date is the most recent date possible to get water quality data from dbhydro.
+    Can be used to check whether dbhydro water quality data is up-to-date.
+
+    Args:
+        date_latest (str): The date of the most recent data of the dbhydro water quality data you have.
+        station (str): The station ID of the water quality data you are checking.
+        test_number (int): The test number of the water quality data you are checking. Test numbers map to parameters such as 'PHOSPHATE, TOTAL AS P'.
+    
+    Returns:
+        bool: True if the date_latest is the most recent date possible to get water quality data from dbhydro, False otherwise
+    """
+    # Get the date range from dbhydro water quality data
+    date_start, date_end = get_dbhydro_water_quality_date_range(station, station_type, test_number)
+    
+    # No end date available
+    if date_end is None:
+        # Assume data is not up-to-date
+        return False
+    
+    # Convert date_latest to a datetime object
+    date_latest_object = pd.to_datetime(date_latest)
+    
+    # Compare given date to last date from dbhydro
+    return date_latest_object >= date_end
 
 
 def get_synthetic_data(date_start: str, df: pd.DataFrame):
@@ -996,14 +1087,31 @@ def get_synthetic_data(date_start: str, df: pd.DataFrame):
     end_month_day = date_end.strftime('%m-%d')
     
     # Filter the DataFrame to include only rows between date_start and date_end for all previous years
-    mask = (df['month_day'] >= start_month_day) & (df['month_day'] <= end_month_day)
+    # (handle year wrap, e.g., Dec -> Jan)
+    wraps_year = start_month_day > end_month_day
+
+    if wraps_year:
+        mask = (
+            (df['month_day'] >= start_month_day) |
+            (df['month_day'] <= end_month_day)
+        )
+    else:
+        mask = (
+            (df['month_day'] >= start_month_day) &
+            (df['month_day'] <= end_month_day)
+        )
+
     filtered_data = df.loc[mask]
     
     # Group by the month and day, then calculate the average for each group
     average_values = filtered_data.groupby('month_day')['Data'].mean()
     # Interpolate in case there are missing values:
     start_date = pd.to_datetime('2001-' + start_month_day)
-    end_date = pd.to_datetime('2001-' + end_month_day)
+
+    if wraps_year:
+        end_date = pd.to_datetime('2002-' + end_month_day)
+    else:
+        end_date = pd.to_datetime('2001-' + end_month_day)
 
     full_dates = pd.date_range(start=start_date, end=end_date)
     full_index = full_dates.strftime('%m-%d')
@@ -1021,6 +1129,128 @@ def get_synthetic_data(date_start: str, df: pd.DataFrame):
     return df
 
 
+def df_replace_missing_with_nan(df: pd.DataFrame, qualifier_codes: set = {'M', 'N'}, no_data_value: float = -99999.0) -> pd.DataFrame:
+    """
+    Replace values in the 'value' column of the DataFrame with NaN where the 'qualifier' column contains specified qualifier codes.
+    
+    This was designed to work with dataframes created from dbhydro_py response data.
+    The dataframe must have 'value' and 'qualifier' columns.
+    Qualifier/Codes can be found here: https://insightsdata.sfwmd.gov/#/reference-tables?lookup=qualityCode
+    
+    Args:
+        df (pd.DataFrame): DataFrame that was created from a dbhydro_py response. Must have value and qualifier columns.
+        qualifier_codes (set, optional): Set of qualifier codes indicating missing data. Defaults to {'M', 'N'}.
+        no_data_value (float, optional): Value representing no data. Defaults to -99999.0. Values equal to this will also be replaced with NaN.
+    
+    Returns:
+        pd.DataFrame: DataFrame with specified values replaced with NaN.
+    """
+    # Replace 0 values with NaN when their qualifier is in qualifier_codes
+    # 'M' = Missing, 'N' = Not Yet Available
+    # Qualifier/Codes can be found here: https://insightsdata.sfwmd.gov/#/reference-tables?lookup=qualityCode
+    df.loc[df['qualifier'].isin(qualifier_codes), 'value'] = np.nan
+    
+    # Also replace no_data_value with NaN
+    df.loc[np.isclose(df['value'], no_data_value), 'value'] = np.nan
+    
+    # Return modified dataframe
+    return df
+
+
+def get_dbhydro_water_quality_date_range(station: str, station_type: Literal['SITE', 'STATION'], test_number: int) -> Tuple[pd.Timestamp | None, pd.Timestamp | None]:
+    """Get the start date and end date for the given station and test number from DBHYDRO water quality data.
+    
+    Args:
+        station (str): The station names.
+        station_type (Literal['SITE', 'STATION']): The type of the station.
+        test_number (int): The test number of the data. Test numbers map to parameters such as 'PHOSPHATE, TOTAL AS P'.
+    
+    Returns:
+        Tuple[pd.Timestamp | None, pd.Timestamp | None]: A tuple containing the start date and end date in 'MM/DD/YYYY' format.
+    """
+    response = get_dbhydro_water_quality_metadata([(station, station_type)], [test_number])
+    
+    # No data given back by api
+    if response is None:
+        return (None, None)
+    
+    # Get the date range from the response
+    if 'results' in response:
+        results = response['results']
+        if len(results) > 0:
+            # Find the first non-None start and end dates
+            date_start = None
+            date_end = None
+            for result in results:
+                date_start = result.get('startDate', None)
+                date_end = result.get('endDate', None)
+                
+                # Dates found
+                if date_start is not None and date_end is not None:
+                    break
+            
+            # If no valid dates were found, return early
+            if date_start is None or date_end is None:
+                return (date_start, date_end)
+            
+            # Find the earliest start date and latest end date
+            for result in results:
+                date_start_current = result.get('startDate', None)
+                date_end_current = result.get('endDate', None)
+                if date_start_current is not None and pd.to_datetime(date_start_current) < pd.to_datetime(date_start):
+                    date_start = date_start_current
+                if date_end_current is not None and pd.to_datetime(date_end_current) > pd.to_datetime(date_end):
+                    date_end = date_end_current
+            
+            # Convert dates to datetime objects
+            if date_start is not None:
+                date_start = pd.to_datetime(date_start)
+            if date_end is not None:
+                date_end = pd.to_datetime(date_end)
+            
+            # Return the earliest start date and latest end date
+            return (date_start, date_end)
+    
+    # No results found
+    return (None, None)
+            
+
+def get_dbhydro_api_keys_from_environment() -> dict[str, str]:
+    """Get DBHYDRO API keys from environment variables.
+
+    Returns:
+        Dict[str, str]: A dictionary containing the DBHYDRO API keys where dict keys are 'client_id' and 'client_secret'.
+    """
+    # Get API keys from environment variables
+    api_keys = {
+        "client_id": os.environ.get("DBHYDRO_API_CLIENT_ID", ""),
+        "client_secret": os.environ.get("DBHYDRO_API_CLIENT_SECRET", ""),
+    }
+    
+    # Return the API keys
+    return api_keys
+
+
+def get_dbhydro_api_keys() -> dict[str, str]:
+    """Get DBHYDRO API keys.
+
+    Returns:
+        Dict[str, str]: A dictionary containing the DBHYDRO API keys where dict keys are 'client_id' and 'client_secret'.
+    """
+    return get_dbhydro_api_keys_from_environment()
+
+
+def get_dbhydro_api() -> DbHydroApi:
+    """Get a configured DbHydroApi instance.
+
+    Returns:
+        DbHydroApi: An instance of the DbHydroApi class.
+    """
+    api_keys = get_dbhydro_api_keys()
+    dbhydro_api = DbHydroApi.with_default_adapter(client_id=api_keys["client_id"], client_secret=api_keys["client_secret"])
+    return dbhydro_api
+
+
 if __name__ == "__main__":
     if sys.argv[1] == "get_dbkeys":
         get_dbkeys(

loone_data_prep/water_level_data/get_all.py

@@ -4,8 +4,7 @@ import requests
 import uuid
 from datetime import datetime
 from loone_data_prep.water_level_data import hydro
-from loone_data_prep.flow_data.get_forecast_flows import get_stations_latitude_longitude
-from loone_data_prep.utils import find_last_date_in_csv, dbhydro_data_is_latest
+from loone_data_prep.utils import find_last_date_in_csv, dbhydro_data_is_latest, get_stations_latitude_longitude
 import pandas as pd
 
 DATE_NOW = datetime.now().date().strftime("%Y-%m-%d")
@@ -13,11 +12,11 @@ DATE_NOW = datetime.now().date().strftime("%Y-%m-%d")
 D = {
     "LO_Stage": {"dbkeys": ["16022", "12509", "12519", "16265", "15611"], "datum": "NGVD29"},
     "LO_Stage_2": {"dbkeys": ["94832"], "date_min": "2024-04-30", "datum": "NAVD88"},
-    "Stg_3ANW": {"dbkeys": ["LA369"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29"},
-    "Stg_2A17": {"dbkeys": ["16531"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29"},
-    "Stg_3A3": {"dbkeys": ["16532"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29"},
-    "Stg_3A4": {"dbkeys": ["16537"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29"},
-    "Stg_3A28": {"dbkeys": ["16538"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29"}
+    "Stg_3ANW": {"dbkeys": ["LA369"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29", "override_site_codes": {"G3ANW": "3A-NW"}},
+    "Stg_2A17": {"dbkeys": ["16531"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29", "override_site_codes": {"2A-17": "2-17"}},
+    "Stg_3A3": {"dbkeys": ["16532"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29", "override_site_codes": {"3A-3": "3-63"}},
+    "Stg_3A4": {"dbkeys": ["16537"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29", "override_site_codes": {"3A-4": "3-64"}},
+    "Stg_3A28": {"dbkeys": ["16538"], "date_min": "1972-01-01", "date_max": "2023-04-30", "datum": "NGVD29", "override_site_codes": {"3A-28": "3-65"}},
 }
 
 
@@ -25,9 +24,6 @@ def main(workspace: str, d: dict = D) -> dict:
     missing_files = []
     failed_downloads = []   # List of file names that the script failed to get the latest data for (but the files still exist)
     
-    # Get the date of the latest data in LO_Stage_2.csv
-    date_latest_lo_stage_2 = find_last_date_in_csv(workspace, "LO_Stage_2.csv")
-    
     for name, params in d.items():
         # Get the date of the latest data in the csv file
         date_latest = find_last_date_in_csv(workspace, f"{name}.csv")
@@ -35,10 +31,18 @@ def main(workspace: str, d: dict = D) -> dict:
         # File with data for this dbkey does NOT already exist (or possibly some other error occurred)
         if date_latest is None:
             print(f"Getting all water level data for {name}.")
+            params['date_max'] = DATE_NOW
             hydro.get(workspace, name, **params)
         else:
             # Check whether the latest data is already up to date.
-            if dbhydro_data_is_latest(date_latest):
+            requires_data_download = False
+            for dbkey in params['dbkeys']:
+                if not dbhydro_data_is_latest(date_latest, dbkey):
+                    requires_data_download = True
+                    break
+            
+            # Data is already up to date
+            if not requires_data_download:
                 # Notify that the data is already up to date
                 print(f'Downloading of new water level data skipped for {name}. Data is already up to date.')
                 continue
@@ -50,21 +54,23 @@ def main(workspace: str, d: dict = D) -> dict:
             
             try:
                 # Download only the new data
-                print(f'Downloading new water level data for {name} starting from date {date_latest}')
-                hydro.get(workspace, name, dbkeys=params['dbkeys'], date_min=date_latest, date_max=DATE_NOW, datum=params['datum'])
+                date_next = (datetime.strptime(date_latest, "%Y-%m-%d") + pd.DateOffset(days=1)).date().strftime("%Y-%m-%d")
+                print(f'Downloading new water level data for {name} starting from date {date_next}')
+                kwargs = {}
+                if 'override_site_codes' in params:
+                    kwargs['override_site_codes'] = params['override_site_codes']
+                hydro.get(workspace, name, dbkeys=params['dbkeys'], date_min=date_next, date_max=DATE_NOW, datum=params['datum'], **kwargs)
                 
                 # Read in the original data and the newly downloaded data
-                df_original = pd.read_csv(os.path.join(workspace, original_file_name_temp), index_col=0)
-                df_new = pd.read_csv(os.path.join(workspace, original_file_name), index_col=0)
-                
-                # For get_hydro() calls with multiple dbkeys, remove the row corresponding to the latest date from the downloaded data.
-                # When get_hydro() is given multiple keys its returned data starts from the date given instead of the day after like it
-                # does when given a single key.
-                if len(params['dbkeys']) > 1:
-                    df_new = df_new[df_new['date'] != date_latest]
+                df_original = pd.read_csv(os.path.join(workspace, original_file_name_temp), index_col='date')
+                df_new = pd.read_csv(os.path.join(workspace, original_file_name), index_col='date')
                 
                 # Merge the new data with the original data
-                df_merged = pd.concat([df_original, df_new], ignore_index=True)
+                df_merged = pd.concat([df_original, df_new], ignore_index=False)
+                
+                # Ensure an integer index (for backwards compatibility)
+                df_merged.reset_index(inplace=True)
+                df_merged.drop(columns=['Unnamed: 0'], inplace=True, errors='ignore')
                 
                 # Write out the merged data
                 df_merged.to_csv(os.path.join(workspace, original_file_name))
@@ -102,6 +108,10 @@ def main(workspace: str, d: dict = D) -> dict:
         lat_long_map = get_stations_latitude_longitude(["L OKEE"])
         latitude, longitude = lat_long_map["L OKEE"]
         
+        # Load the LO_Stage.csv file
+        df_lo_stage = pd.read_csv(os.path.join(workspace, "LO_Stage.csv"), index_col="date")
+        df_lo_stage.index = pd.to_datetime(df_lo_stage.index)
+        
         # Load the LO_Stage_2.csv file
         df_lo_stage_2 = pd.read_csv(os.path.join(workspace, "LO_Stage_2.csv"), index_col="date")
         df_lo_stage_2.index = pd.to_datetime(df_lo_stage_2.index)
@@ -109,21 +119,24 @@ def main(workspace: str, d: dict = D) -> dict:
         # Output Progress
         print("Converting NAVD88 to NGVD29 for 'L OKEE's new dbkey...\n")
         
-        # Use only the data that is not already in the LO_Stage.csv file
-        if date_latest_lo_stage_2 is not None:
-            date_start = datetime.strptime(date_latest_lo_stage_2, "%Y-%m-%d") + pd.DateOffset(days=1)
-            df_lo_stage_2 = df_lo_stage_2.loc[date_start:]
+        # Use only the data that is not already in the LO_Stage.csv file and exists in the LO_Stage_2.csv file
+        common_dates = df_lo_stage.index.intersection(df_lo_stage_2.index)
         
-        # Convert the stage values from NAVD88 to NGVD29
-        lo_stage_2_dates = df_lo_stage_2.index.tolist()
-        lo_stage_2_values_navd88 = df_lo_stage_2["L OKEE_STG_ft NGVD29"].tolist()
-        lo_stage_2_values_ngvd29 = []
+        missing_mask = (
+            df_lo_stage.loc[common_dates, "L OKEE_STG_ft NGVD29"].isna() &
+            df_lo_stage_2.loc[common_dates, "L OKEE_STG_ft NGVD29"].notna()
+        )
         
-        for i in range(0, len(lo_stage_2_values_navd88)):
-            date = lo_stage_2_dates[i]
-            value = lo_stage_2_values_navd88[i]
+        missing_dates: pd.DatetimeIndex = common_dates[missing_mask]
+        missing_dates = missing_dates.to_list()
+        
+        # Convert the stage values from NAVD88 to NGVD29 for the missing dates
+        converted_values = {}
+        for date in missing_dates:
             try:
-                lo_stage_2_values_ngvd29.append(_convert_navd88_to_ngvd29(latitude, longitude, value, date.year))
+                navd88_value = df_lo_stage_2.at[date, "L OKEE_STG_ft NGVD29"]
+                ngvd29_value = _convert_navd88_to_ngvd29(latitude, longitude, navd88_value, date.year)
+                converted_values[date] = ngvd29_value
             except Exception as e:
                 convert_failure = True
                 print(str(e))
@@ -132,20 +145,15 @@ def main(workspace: str, d: dict = D) -> dict:
         # Check for conversion failure
         if not convert_failure:        
             # Update the LO_Stage.csv file with the converted values
-            df_lo_stage = pd.read_csv(os.path.join(workspace, "LO_Stage.csv"), index_col="date")
-            df_lo_stage.index = pd.to_datetime(df_lo_stage.index)
-            
-            for i in range(0, len(lo_stage_2_values_ngvd29)):
-                # Get the current date and value
-                date = lo_stage_2_dates[i]
-                value = lo_stage_2_values_ngvd29[i]
-                
-                # Update the value in the LO_Stage dataframe
+            for date, value in converted_values.items():
                 df_lo_stage.at[date, "L OKEE_STG_ft NGVD29"] = value
             
             # Reset the index
             df_lo_stage.reset_index(inplace=True)
-            df_lo_stage.drop(columns=["Unnamed: 0"], inplace=True)
+            
+            # Drop Unnamed: 0 column that might have been added
+            if "Unnamed: 0" in df_lo_stage.columns:
+                df_lo_stage.drop(columns=["Unnamed: 0"], inplace=True)
             
             # Save the updated LO_Stage.csv file
             df_lo_stage.to_csv(os.path.join(workspace, "LO_Stage.csv"))