loone-data-prep 0.1.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

loone_data_prep/forecast_scripts/forecast_stages.py

@@ -0,0 +1,40 @@
+import pandas as pd
+from datetime import timedelta
+
+def forecast_stages(workspace_path: str):
+    """
+    Forecasts the next 15 days of WCA stages based on historical data.
+    
+    Args:
+        workspace_path (str): Path to the workspace directory.
+    """
+    # Load historical data
+    stages = pd.read_csv(f"{workspace_path}/WCA_Stages_Inputs.csv")
+
+    # Convert 'date' column to datetime
+    stages['date'] = pd.to_datetime(stages['date'])
+
+    # Start forecast from today (normalized to remove time)
+    start_date = pd.Timestamp.today().normalize()
+
+    # Generate forecast for the next 15 days
+    forecast_rows = []
+    for i in range(16):
+        forecast_date = start_date + timedelta(days=i)
+        month = forecast_date.month
+        day = forecast_date.day
+
+        # Filter historical rows for the same month and day
+        same_day_rows = stages[(stages['date'].dt.month == month) & (stages['date'].dt.day == day)]
+
+        if not same_day_rows.empty:
+            mean_values = same_day_rows.drop(columns='date').mean()
+            forecast_row = {'date': forecast_date}
+            forecast_row.update(mean_values.to_dict())
+            forecast_rows.append(forecast_row)
+
+    # Create forecast DataFrame
+    forecast_df = pd.DataFrame(forecast_rows)
+
+    forecast_df.to_csv(f"{workspace_path}/WCA_Stages_Inputs_Predicted.csv", index=False)
+    return

loone_data_prep/forecast_scripts/predict_PI.py

@@ -0,0 +1,51 @@
+import pandas as pd
+from datetime import datetime, timedelta
+import argparse
+
+def extend_PI(PI_path, output_path):
+    df = pd.read_csv(PI_path, header=None, skiprows=1, names=["date", "PI"])
+    df["date"] = pd.to_datetime(df["date"], format="%Y%m%d")
+    # Extract month and day for grouping
+    df["month_day"] = df["date"].dt.strftime("%m-%d")
+    # Sort data in case it's unordered
+    df = df.sort_values(by="date").reset_index(drop=True)
+
+    # Compute historical average PI for each month-day
+    average_pi = df.groupby("month_day")["PI"].mean().reset_index()
+
+    # Generate future dates (today + next 16 days)
+    today = datetime.today()
+    future_dates = [today + timedelta(days=i) for i in range(17)]
+    future_df = pd.DataFrame({"date": future_dates})
+
+    # Extract month-day from future dates to match historical data
+    future_df["month_day"] = future_df["date"].dt.strftime("%m-%d")
+
+    # Merge with historical averages
+    future_df = future_df.merge(average_pi, on="month_day", how="left")
+
+    # Append the new rows to the original dataframe
+    df_extended = pd.concat([df, future_df[["date", "PI"]]], ignore_index=True)
+    df_extended.drop(columns=["month_day"], inplace=True)
+    df_extended.set_index('date', inplace=True)
+    df_extended = df_extended.resample('W-FRI').mean().reset_index()
+
+    # Save the updated dataframe to CSV
+    df_extended.to_csv(output_path, index=False)
+    
+def main():
+    # Set up command-line argument parsing
+    parser = argparse.ArgumentParser(description="Download and process weather forecast data.")
+    parser.add_argument("PI_path", help="Path to the historical palmer index file.")
+    parser.add_argument("output_path", help="Path to save the new output file path.")
+
+
+    # Parse the arguments
+    args = parser.parse_args()
+
+    # Call the function with the provided file path
+    extend_PI(args.PI_path, args.output_path)
+
+
+if __name__ == "__main__":
+    main()

loone_data_prep/forecast_scripts/trib_cond.py

@@ -0,0 +1,84 @@
+import pandas as pd
+from datetime import datetime
+from datetime import date, timedelta
+import argparse
+
+def create_trib_cond (weather_data, net_inflows, main_tributary, PI, output, ensemble):
+    # TODO - check that all these unit are right
+    future_date = date.today() + timedelta(days=15)
+    today = date.today()
+
+    all_data = pd.read_csv(weather_data)
+
+    all_data['date'] = pd.to_datetime(all_data['datetime']).dt.date
+    all_data = all_data[(all_data['date'] >= today) & (all_data['date'] <= future_date)]
+    all_data = all_data.set_index(['date'])
+    all_data.index = pd.to_datetime(all_data.index, unit='ns')
+    Net_RF_Weekly =  all_data.resample('W-FRI').sum()
+    # Net Inflows cfs
+    Net_Inflows = pd.read_csv(net_inflows)
+    Net_Inflows['date'] = pd.to_datetime(Net_Inflows['date']).dt.date
+    Net_Inflows = Net_Inflows[(Net_Inflows['date'] >= today) & (Net_Inflows['date'] <= future_date)]
+    #This is just the sum of the inflows that we want to read in 
+    Net_Inflows['Net_Inflows'] = Net_Inflows['Netflows_acft']*(43560)  # acft to cf
+    Net_Inflows = Net_Inflows.set_index(['date'])
+    Net_Inflows.index = pd.to_datetime(Net_Inflows.index, unit='ns')
+    Net_Inflow_Weekly = Net_Inflows.resample('W-FRI').mean()
+    # S65 cfs
+    S65E = pd.read_csv(main_tributary)
+    S65E['date'] = pd.to_datetime(S65E['date']).dt.date
+    S65E = S65E[(S65E['date'] >= today) & (S65E['date'] <= future_date)]
+    #We want specifically S65_Q
+    #Check that the units are right
+    S65E = S65E.set_index(['date'])
+    S65E = S65E / (0.0283168466 * 86400)  # Convert all columns from cmd to cfs  
+    S65E.index = pd.to_datetime(S65E.index, unit='ns')  # Ensure index is datetime
+    S65E_Weekly = S65E.resample('W-FRI').mean()
+    # PI
+    PI_week_data = pd.DataFrame(S65E_Weekly.index, columns=['date'])
+    PI_week_data['date'] = pd.to_datetime(PI_week_data['date'])
+
+    PI_data = pd.read_csv(PI)
+    PI_data['date'] = pd.to_datetime(PI_data['date'])
+
+    PI = PI_week_data.merge(PI_data[['date', 'PI']], on='date', how='left')
+
+    ensemble_col = f"ensemble_{ensemble:02d}"
+
+    # Create the initial DataFrame with the date
+    Trib_Cond_Wkly = pd.DataFrame(S65E_Weekly.index, columns=['date'])
+
+    # Calculate NetRF and NetInf
+    Trib_Cond_Wkly['NetRF'] = Net_RF_Weekly['tp_corrected'].values - Net_RF_Weekly['evapotranspiration'].values
+    Trib_Cond_Wkly['NetInf'] = Net_Inflow_Weekly['Net_Inflows'].values
+
+    # Select only the desired ensemble column and rename it
+    S65E_selected = S65E_Weekly[[ensemble_col]].rename(columns={ensemble_col: "S65E"})
+
+    # Merge it into Trib_Cond_Wkly
+    Trib_Cond_Wkly = Trib_Cond_Wkly.merge(S65E_selected, left_on="date", right_index=True, how="left")
+
+    # Add the Palmer Index
+    Trib_Cond_Wkly['Palmer'] = PI['PI'].values
+
+    # Export to CSV
+    Trib_Cond_Wkly.to_csv(output, index=False)
+    
+def main():
+    # Set up command-line argument parsing
+    parser = argparse.ArgumentParser(description="Download and process weather forecast data.")
+    parser.add_argument("weather_data", help="Path to the weather forecasts.")
+    parser.add_argument("net_inflows", help="Path to the net inflow forecasts.")
+    parser.add_argument("main_tributary", help="Path to save the S65E forecasts.")
+    parser.add_argument("PI", help="Path to the Palmer Index forecasts.")
+    parser.add_argument("output", help="Path to save the trib file")
+
+    # Parse the arguments
+    args = parser.parse_args()
+
+    # Call the function with the provided file path
+    create_trib_cond(args.file_path, args.net_inflows, args.main_tributary, args.PI, args.output)
+
+
+if __name__ == "__main__":
+    main()

loone_data_prep/forecast_scripts/weather_forecast.py

@@ -0,0 +1,155 @@
+from herbie import FastHerbie
+from datetime import datetime
+import pandas as pd
+import openmeteo_requests
+import argparse
+import requests_cache
+from retry_requests import retry
+import warnings
+
+warnings.filterwarnings("ignore", message="Will not remove GRIB file because it previously existed.")
+
+
+def download_weather_forecast (file_path):
+    # Get today's date in the required format
+    today_str = datetime.today().strftime('%Y-%m-%d 00:00')
+
+    # Define variables to download and extract
+    variables = {
+        "10u": "10u", 
+        "ssrd": "ssrd", 
+        "tp": "tp",
+        "10v": "10v",
+    }
+
+    # Define point of interest
+    points = pd.DataFrame({"longitude": [-80.7976], "latitude": [26.9690]})
+
+    # Initialize FastHerbie
+    FH = FastHerbie([today_str], model="ifs", fxx=range(0, 360, 3))
+    dfs = []
+
+    for var_key, var_name in variables.items():
+        print(f"Processing {var_key}...")
+
+        # Download and load the dataset
+        FH.download(f":{var_key}")
+        ds = FH.xarray(f":{var_key}", backend_kwargs={"decode_timedelta": True})
+
+        # Extract point data
+        dsi = ds.herbie.pick_points(points, method="nearest")
+
+        # Extract the correct variable name dynamically
+        if var_name == "10u":
+            var_name_actual = "u10"  # Map 10u to u10
+        elif var_name == "10v":
+            var_name_actual = "v10"  # Map 10v to v10
+        else:
+            var_name_actual = var_name  # For ssrd and tp, use the same name
+
+        # Extract time series
+        time_series = dsi[var_name_actual].squeeze()
+
+        # Convert to DataFrame
+        df = time_series.to_dataframe().reset_index()
+
+        # Convert `valid_time` to datetime
+        if "valid_time" in df.columns:
+            df = df.rename(columns={"valid_time": "datetime"})
+        elif "step" in df.columns and "time" in dsi.coords:
+            df["datetime"] = dsi.time.values[0] + df["step"]
+
+        # Keep only datetime and variable of interest
+        df = df[["datetime", var_name_actual]].drop_duplicates()
+        
+        # Append to list
+        dfs.append(df)
+
+        # Print extracted data
+        # print(df)
+
+    # Merge all variables into a single DataFrame
+    final_df = dfs[0]
+    for df in dfs[1:]:
+        final_df = final_df.merge(df, on="datetime", how="outer")
+    print(final_df)
+    # Calculate wind speed
+    final_df["wind_speed"] = (final_df["u10"] ** 2 + final_df["v10"] ** 2) ** 0.5
+
+    #rainfall corrected: OLS Regression Equation: Corrected Forecast = 0.7247 * Forecast + 0.1853
+    final_df["tp_corrected"] = 0.7247 * final_df["tp"] + 0.1853
+
+    #wind speed correction: Corrected Forecast = 0.4167 * Forecast + 4.1868
+    final_df["wind_speed_corrected"] = 0.4167 * final_df["wind_speed"] + 4.1868
+
+    #radiation correction will need to be fixed because it was done on fdir instead of ssdr
+    #radiation corrected: Corrected Forecast = 0.0553 * Forecast - 0.0081
+    final_df["ssrd_corrected"] = 0.0553 * final_df["ssrd"] - 0.0081
+
+    # Setup the Open-Meteo API client with cache and retry on error
+    cache_session = requests_cache.CachedSession('.cache', expire_after = 3600)
+    retry_session = retry(cache_session, retries = 5, backoff_factor = 0.2)
+    openmeteo = openmeteo_requests.Client(session = retry_session)
+
+    # Make sure all required weather variables are listed here
+    # The order of variables in hourly or daily is important to assign them correctly below
+    url = "https://api.open-meteo.com/v1/forecast"
+    params = {
+        "latitude": 26.9690,
+        "longitude": -80.7976,
+        "hourly": "evapotranspiration",
+        "forecast_days": 16,
+        "models": "gfs_seamless"
+    }
+    responses = openmeteo.weather_api(url, params=params)
+
+
+    # Process first location. Add a for-loop for multiple locations or weather models
+    response = responses[0]
+
+    hourly = response.Hourly()
+    hourly_evapotranspiration = hourly.Variables(0).ValuesAsNumpy()
+
+    hourly_data = {"date": pd.date_range(
+        start = pd.to_datetime(hourly.Time(), unit = "s", utc = True),
+        end = pd.to_datetime(hourly.TimeEnd(), unit = "s", utc = True),
+        freq = pd.Timedelta(seconds = hourly.Interval()),
+        inclusive = "left"
+    )}
+
+    hourly_data["evapotranspiration"] = hourly_evapotranspiration
+
+    hourly_dataframe = pd.DataFrame(data = hourly_data)
+
+    # Convert datetime to date for merging
+    final_df['date'] = final_df['datetime']
+    # Ensure final_df['date'] is timezone-aware (convert to UTC)
+    final_df['date'] = pd.to_datetime(final_df['date'], utc=True)
+
+    # Ensure hourly_dataframe['date'] is also timezone-aware (convert to UTC)
+    hourly_dataframe['date'] = pd.to_datetime(hourly_dataframe['date'], utc=True)
+
+    # Merge while keeping only matching dates from final_df
+    merged_df = final_df.merge(hourly_dataframe, on='date', how='left')
+
+    # Print final combined DataFrame
+    merged_df.drop(columns=['date'], inplace=True)
+    # print(merged_df)
+
+    merged_df.to_csv(file_path, index=False)
+
+
+def main():
+    # Set up command-line argument parsing
+    parser = argparse.ArgumentParser(description="Download and process weather forecast data.")
+    parser.add_argument("file_path", help="Path to save the resulting CSV file.")
+
+    # Parse the arguments
+    args = parser.parse_args()
+
+    # Call the function with the provided file path
+    download_weather_forecast(args.file_path)
+
+
+if __name__ == "__main__":
+    main()

loone_data_prep/utils.py

@@ -193,7 +193,7 @@ DEFAULT_PREDICTION_STATIONS_IDS = [
     "S135_P",
     "S135_C",
 ]
-DEFAULT_EXPFUNC_CONSTANTS = {
+DEFAULT_EXPFUNC_PHOSPHATE_CONSTANTS = {
     "S65E_S": {"a": 2.00040151533473, "b": 0.837387838314323},
     "S71_S": {"a": 2.55809777403484, "b": 0.765894033054918},
     "S72_S": {"a": 2.85270576092534, "b": 0.724935760736887},
@@ -208,7 +208,21 @@ DEFAULT_EXPFUNC_CONSTANTS = {
     "S135_P": {"a": 2.50975664040355, "b": 0.760702496334553},
     "S135_C": {"a": 2.43076251736749, "b": 0.759494593788417},
 }
-
+DEFAULT_EXPFUNC_NITROGEN_CONSTANTS = {
+    "FISHP": {"a": 3.45714698709252, "b": 0.592252136022012},
+    "S4_P": {"a": 1.2337557014752, "b": 1.04595934798695},
+    "S65E_S": {"a": 4.71575889172016, "b": 0.505549283553318},
+    "S71_S": {"a": 3.97701995028333, "b": 0.606281118481932},
+    "S72_S": {"a": 2.36651051985955, "b": 0.774589654354149},
+    "S84_S": {"a": 2.69855941365441, "b": 0.697201188144741},
+    "S127_C": {"a": 2.22368957908813, "b": 0.758610540522343},
+    "S127_P": {"a": 2.19477310222979, "b": 0.786485799309641},
+    "S133_P": {"a": 1.79092549100026, "b": 0.882497515298829},
+    "S154_C": {"a": 2.88850639994145, "b": 0.665252221554856},
+    "S191_S": {"a": 3.99798269355392, "b": 0.586177156114969},
+    "S135_C": {"a": 6.44418674308781, "b": 0.322821841402605},
+    "S135_P": {"a": 3.09890183766129, "b": 0.657896838486496},
+}
 
 @retry(RRuntimeError, tries=5, delay=15, max_delay=60, backoff=2)
 def get_dbkeys(
@@ -298,7 +312,7 @@ def data_interpolations(
         Data_df["Yr_M"] = pd.to_datetime(Data_df["date"]).dt.to_period("M")
         start_date = Data_df["date"].iloc[0]
         end_date = Data_df["date"].iloc[-1]
-        date_rng = pd.date_range(start=start_date, end=end_date, freq="M")
+        date_rng = pd.date_range(start=start_date, end=end_date, freq="ME")
         Monthly_df = pd.DataFrame(date_rng, columns=["date"])
         Monthly_df["Yr_M"] = pd.to_datetime(Monthly_df["date"]).dt.to_period(
             "M"
@@ -705,28 +719,47 @@ def nutrient_prediction(
     input_dir: str,
     output_dir: str,
     station_ids: dict = DEFAULT_PREDICTION_STATIONS_IDS,
-    constants: dict = DEFAULT_EXPFUNC_CONSTANTS,
+    constants: dict = DEFAULT_EXPFUNC_PHOSPHATE_CONSTANTS,
+    nutrient: str = "PHOSPHATE",
 ) -> None:
+    """Predict nutrient loads for the given station IDs.
+    
+    Args:
+        input_dir (str): Path to the directory where the input files are located.
+        output_dir (str): Path to the directory where the output files will be saved.
+        station_ids (list, optional): List with station IDs to do predictions for. Defaults to DEFAULT_PREDICTION_STATIONS_IDS.
+        constants (dict, optional): Dictionary with constants for the exponential function. Defaults to DEFAULT_EXPFUNC_PHOSPHATE_CONSTANTS.
+        nutrient (str, optional): Nutrient to predict. Defaults to "PHOSPHATE". Options are "PHOSPHATE" or "NITROGEN".
+    """
     for station in station_ids:
         print(f"Predicting nutrient loads for station: {station}.")
         # Construct paths for flow file
         flow_file_path = ""
         flow_file_path_exists = True
-        try:
-            flow_file_path = glob(
-                os.path.join(input_dir, f"{station}*_FLOW_cmd_geoglows.csv")
-            )[0]
-        except Exception as e:
-            flow_file_path_exists = False
-
-        # Check if data file exists
-        if flow_file_path_exists and os.path.exists(flow_file_path):
-            # If it exists, read in the data
-            flow = pd.read_csv(flow_file_path)
+        # Manually define matches for forecast case
+        station_file_map = {
+            'S65E_S': f"{input_dir}/750072741_INFLOW_cmd_geoglows.csv",
+            'S71_S': f"{input_dir}/750068601_MATCHED_cmd_geoglows.csv",
+            'FISHP': f"{input_dir}/750053213_MATCHED_cmd_geoglows.csv",
+            'S84_S': f"{input_dir}/750069782_INFLOW_cmd_geoglows.csv",
+            'S133_P': f"{input_dir}/750035446_INFLOW_cmd_geoglows.csv",
+            'S154_C': f"{input_dir}/750064453_INFLOW_cmd_geoglows.csv",
+            'S135_P': f"{input_dir}/750052624_MATCHED_cmd_geoglows.csv",
+            'S135_C': f"{input_dir}/750052624_MATCHED_cmd_geoglows.csv",
+        }
+
+        if station in station_file_map:
+            flow_file_path = station_file_map[station]
+            if os.path.exists(flow_file_path):
+                flow = pd.read_csv(flow_file_path)
+            else:
+                print(
+                    f"Skipping nutrient prediction for station: {station}. Forecast file path does not exist."
+                )
+                continue
         else:
-            # If it doesn't exist, skip to the next iteration of the loop
             print(
-                f"Skipping nutrient prediction for station: {station}. Flow file does not exist."
+                f"Skipping nutrient prediction for station: {station}. No forecast match defined."
             )
             continue
 
@@ -788,13 +821,13 @@ def nutrient_prediction(
 
         # Save the predicted TP loads to a CSV file
         out_dataframe.to_csv(
-            os.path.join(output_dir, f"{station}_PHOSPHATE_predicted.csv")
+            os.path.join(output_dir, f"{station}_{nutrient}_predicted.csv")
         )
 
         # Save the predicted TP loads to a CSV file (in input_dir)
         # Output is needed in input_dir by GEOGLOWS_LOONE_DATA_PREP.py and in output_dir for graph visualization in the app
         out_dataframe.to_csv(
-            os.path.join(input_dir, f"{station}_PHOSPHATE_predicted.csv")
+            os.path.join(input_dir, f"{station}_{nutrient}_predicted.csv")
         )
 
 

{loone_data_prep-0.1.9.dist-info → loone_data_prep-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: loone_data_prep
-Version: 0.1.9
+Version: 1.1.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>
@@ -20,10 +20,15 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: rpy2
 Requires-Dist: retry
-Requires-Dist: numpy <2
+Requires-Dist: numpy<2
 Requires-Dist: pandas
 Requires-Dist: scipy
-Requires-Dist: geoglows ==0.27.1
+Requires-Dist: geoglows>=2.0.0
+Requires-Dist: herbie
+Requires-Dist: openmeteo_requests
+Requires-Dist: requests_cache
+Requires-Dist: retry-requests
+Dynamic: license-file
 
 LOONE_DATA_PREP
 # LOONE_DATA_PREP

{loone_data_prep-0.1.9.dist-info → loone_data_prep-1.1.1.dist-info}/RECORD

@@ -1,15 +1,20 @@
-loone_data_prep/GEOGLOWS_LOONE_DATA_PREP.py,sha256=vtDA341YIXLHi9fLuGf6-Kf2ImhNnRXt8HRxemAAP14,35465
-loone_data_prep/LOONE_DATA_PREP.py,sha256=Yqc6A0iGCXOYZDDC58Q1Gfu1e0CKzojr_SwX7Z25ATU,67761
+loone_data_prep/GEOGLOWS_LOONE_DATA_PREP.py,sha256=QQ2VMp7TmcKiffxwYhOc3uDUG4wXf9CTOqWMy7c4xMI,35809
+loone_data_prep/LOONE_DATA_PREP.py,sha256=aHC1gYR4D7yUWk6I_ydR6nzBC3nvZlt7tD6kKfOqh2A,68302
 loone_data_prep/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 loone_data_prep/data_analyses_fns.py,sha256=BZ7famrSKoUfExQvZfbl72CyADHLb-zzgdWZ-kLJxcQ,4603
-loone_data_prep/utils.py,sha256=-NNU6HA20gWNpdVUtVyjaVlQ_5qv-BQxcElQ6Os9Cow,33115
+loone_data_prep/utils.py,sha256=CObio2wEPvdNhMJjn36jq0ArQURyGYZBqidh5crb0JU,35229
 loone_data_prep/flow_data/S65E_total.py,sha256=szNUfj0EyyyDzuKNhTGAZtWc5owiOpxYS55YTt4u19k,2835
 loone_data_prep/flow_data/__init__.py,sha256=u7fENFUZsJjyl13Bc9ZE47sHMKmjxtqXhV9t7vDTm7Y,93
-loone_data_prep/flow_data/forecast_bias_correction.py,sha256=ydoZ0UmDZvsPLHsO7cpCFN9Pmj7w_tKjMDy9RK5EoiM,10146
-loone_data_prep/flow_data/get_forecast_flows.py,sha256=-nPkscE9UZbRzGZ_dk0zhKiNM2hOINx21HgSeQrFjaU,14462
+loone_data_prep/flow_data/forecast_bias_correction.py,sha256=pcMH7qR3RZvXOHoYOtP7azNn5rVuRPL9mwgoVk2NeLA,11378
+loone_data_prep/flow_data/get_forecast_flows.py,sha256=0TvOMR_Z2FbqnIEQATugpdluwhzQ0Y4tEyZHoRIaAYU,16580
 loone_data_prep/flow_data/get_inflows.py,sha256=xKuSyJBdPrpjqMdRiyNDyxwdhYVIgLhiTP0k_1I1uWI,6456
 loone_data_prep/flow_data/get_outflows.py,sha256=x7aisIkbXoTkcubFQLDghX-P8lztPq-tU0dQzoVRTtQ,5620
 loone_data_prep/flow_data/hydro.py,sha256=5MwrzSUTCgPgeC_YGhz-en1CbOMp379Qf5zjpJlp-HM,5312
+loone_data_prep/forecast_scripts/create_forecast_LOWs.py,sha256=_n6haJvGWuCfcgXO1x3ondmsaEDxzPlhJJQJHQhhd10,4864
+loone_data_prep/forecast_scripts/forecast_stages.py,sha256=6S6aHlYi2_t6GAh901KBiBWPueYCwAzyb-AliHJexoU,1373
+loone_data_prep/forecast_scripts/predict_PI.py,sha256=f0n2-gt5t9FKNdpJ5QGpyP2QBFLDGetYzfTYL95Vi_8,1937
+loone_data_prep/forecast_scripts/trib_cond.py,sha256=F2t1FHDmqU9CFOnv1eaSkNE6tsNwsQdKYlhMRgj9xkE,3653
+loone_data_prep/forecast_scripts/weather_forecast.py,sha256=AIHRjcdGUuA2a15ZcLyYws1gtH016QRU0bWIp4Ty2K0,5457
 loone_data_prep/water_level_data/__init__.py,sha256=rgHDDkwccemsZnwUlw2M0h2ML4KmI89yPscmLoxbEHM,43
 loone_data_prep/water_level_data/get_all.py,sha256=arPSWpb0XfQm0GKZJmoWhWdLuuNDxtGVX6_6UuD1_Vs,10885
 loone_data_prep/water_level_data/hydro.py,sha256=PtsNdMXe1Y4e5CzEyLH6nJx_xv8sB90orGcSgxt7nao,3653
@@ -20,8 +25,8 @@ loone_data_prep/water_quality_data/wq.py,sha256=sl6G3iDCk6QUzpHTXPHpRZNMBG0-wHuc
 loone_data_prep/weather_data/__init__.py,sha256=TX58EPgGRzEK_LmLze79lC4L7kU_j3yZf5_iC4nOIP4,45
 loone_data_prep/weather_data/get_all.py,sha256=aCufuxORU51XhXt7LN9wN_V4qtjNt1qRC1UKlI2b3Ko,6918
 loone_data_prep/weather_data/weather.py,sha256=hvceksrGSnDkCjheBVBuPgY1DrdR0ZAtrFB-K2tYTtk,12043
-loone_data_prep-0.1.9.dist-info/LICENSE,sha256=rR1QKggtQUbAoYu2SW1ouI5xPqt9g4jvRRpZ0ZfnuqQ,1497
-loone_data_prep-0.1.9.dist-info/METADATA,sha256=l6KtDZKXWDb_QQbHVC-kN4uQbdHmRoS5TJRG7KTJTd4,4122
-loone_data_prep-0.1.9.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-loone_data_prep-0.1.9.dist-info/top_level.txt,sha256=wDyJMJiCO5huTAuNmvxpjFxtvGaq_8Tr4hFFcXf8jLE,16
-loone_data_prep-0.1.9.dist-info/RECORD,,
+loone_data_prep-1.1.1.dist-info/licenses/LICENSE,sha256=rR1QKggtQUbAoYu2SW1ouI5xPqt9g4jvRRpZ0ZfnuqQ,1497
+loone_data_prep-1.1.1.dist-info/METADATA,sha256=e8bSZDkRefpdg0IvaZ3mEfGsQhd2meoiVfx9IMiQ3Kg,4257
+loone_data_prep-1.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+loone_data_prep-1.1.1.dist-info/top_level.txt,sha256=wDyJMJiCO5huTAuNmvxpjFxtvGaq_8Tr4hFFcXf8jLE,16
+loone_data_prep-1.1.1.dist-info/RECORD,,

{loone_data_prep-0.1.9.dist-info → loone_data_prep-1.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any