import streamlit as st import requests import pandas as pd import json import io import datetime import pandas as pd import numpy as np import requests import base64 import json from calendar import monthrange import pymongo from mongoengine import StringField, ListField, DateTimeField, DictField import matplotlib.pyplot as plt from matplotlib.dates import MonthLocator def mongo_unavs_call(user_input_start_date, user_input_end_date, user_input_past_date): print("Starting mongo_unavs_call") # Connect to the MongoDB database user = "dmarroquin" passw = "tN9XpCCQM2MtYDme" host = "nucmonitordata.xxcwx9k.mongodb.net" client = pymongo.MongoClient( f"mongodb+srv://{user}:{passw}@{host}/?retryWrites=true&w=majority&connectTimeoutMS=100000" ) db = client["data"] collection_past_unavs = db["unavs"] collection_unavs = db["unavs_update"] start_date = f"{user_input_start_date}T00:00:00" end_date = f"{user_input_end_date}T23:59:59" past_date = f"{user_input_past_date}T23:59:59" pipeline_v4 = [ # 1) Expand each results element into its own doc { "$unwind": "$results" }, # 2) Expand each generation_unavailabilities element { "$unwind": "$results.generation_unavailabilities" }, # 3) Keep only those that match your fuel_type + date criteria { "$match": { "results.generation_unavailabilities.production_type": "NUCLEAR", "results.generation_unavailabilities.updated_date": { "$lte": past_date }, "results.generation_unavailabilities.start_date": { "$lte": end_date }, "results.generation_unavailabilities.start_date": { "$gte": start_date }, "results.generation_unavailabilities.end_date": { "$gte": start_date }, "results.generation_unavailabilities.end_date": { "$lte": end_date } } }, # 4) Replace the entire document with just that sub-doc { "$replaceRoot": { "newRoot": "$results.generation_unavailabilities" } } ] pipeline_v6 = [ # 1) Expand each results element into its own doc { "$unwind": "$results" }, # 2) Expand each generation_unavailabilities element { "$unwind": "$results.generation_unavailabilities" }, # 3) Keep only those that match your fuel_type + date criteria { "$match": { "results.generation_unavailabilities.fuel_type": "NUCLEAR", "results.generation_unavailabilities.publication_date": { "$lte": past_date }, "results.generation_unavailabilities.start_date": { "$lte": end_date }, # "results.generation_unavailabilities.start_date": { "$gte": start_date }, "results.generation_unavailabilities.end_date": { "$gte": start_date }, # "results.generation_unavailabilities.end_date": { "$lte": end_date } } }, # 4) Replace the entire document with just that sub-doc { "$replaceRoot": { "newRoot": "$results.generation_unavailabilities" } } ] result1 = list(collection_past_unavs.aggregate(pipeline_v4)) result2 = list(collection_unavs.aggregate(pipeline_v4)) result_v6 = list(collection_unavs.aggregate(pipeline_v6)) merge_results = result1 + result2 + result_v6 return merge_results # --------------------------------------------------------------------------------------- # # Convert the dictionary of dictionaries to JSON def convert_to_json(item): if isinstance(item, dict): return {str(k): convert_to_json(v) for k, v in item.items()} elif isinstance(item, list): return [convert_to_json(i) for i in item] elif isinstance(item, ObjectId): return str(item) else: return item # --------------------------------------------------------------------------------------- # # Function gives the total of the data. When printed as dataframe/excel, # Will give a final row with the total for each plant and the total overall def add_total(data): total_values = {} for key in data: daily_values = data[key] total = sum(daily_values.values()) daily_values["Total"] = total for date, value in daily_values.items(): if date not in total_values: total_values[date] = value else: total_values[date] += value data["Total"] = total_values # --------------------------------------------------------------------------------------- # def nuc_monitor(usr_start_date, usr_end_date, past_date, mongo_db_data): # # Slightly changed metadata to fit the data from the RTE API: ST-LAURENT B 2 --> ST LAURENT 2, .... plants_metadata = {"BELLEVILLE 1": 1310.0, "BELLEVILLE 2": 1310.0, "BLAYAIS 1": 910.0, "BLAYAIS 2": 910.0, "BLAYAIS 3": 910.0, "BLAYAIS 4": 910.0, "BUGEY 2": 910.0, "BUGEY 3": 910.0, "BUGEY 4": 880.0, "BUGEY 5": 880.0, "CATTENOM 1": 1300.0, "CATTENOM 2": 1300.0, "CATTENOM 3": 1300.0, "CATTENOM 4": 1300.0, "CHINON 1": 905.0, "CHINON 2": 905.0, "CHINON 3": 905.0, "CHINON 4": 905.0, "CHOOZ 1": 1500.0, "CHOOZ 2": 1500.0, "CIVAUX 1": 1495.0, "CIVAUX 2": 1495.0, "CRUAS 1": 915.0, "CRUAS 2": 915.0, "CRUAS 3": 915.0, "CRUAS 4": 915.0, "DAMPIERRE 1": 890.0, "DAMPIERRE 2": 890.0, "DAMPIERRE 3": 890.0, "DAMPIERRE 4": 890.0, "FLAMANVILLE 1": 1330.0, "FLAMANVILLE 2": 1330.0, "FLAMANVILLE 3": 1620.0, "GOLFECH 1": 1310.0, "GOLFECH 2": 1310.0, "GRAVELINES 1": 910.0, "GRAVELINES 2": 910.0, "GRAVELINES 3": 910.0, "GRAVELINES 4": 910.0, "GRAVELINES 5": 910.0, "GRAVELINES 6": 910.0, "NOGENT 1": 1310.0, "NOGENT 2": 1310.0, "PALUEL 1": 1330.0, "PALUEL 2": 1330.0, "PALUEL 3": 1330.0, "PALUEL 4": 1330.0, "PENLY 1": 1330.0, "PENLY 2": 1330.0, "ST ALBAN 1": 1335.0, "ST ALBAN 2": 1335.0, "ST LAURENT 1": 915.0, "ST LAURENT 2": 915.0, "TRICASTIN 1": 915.0, "TRICASTIN 2": 915.0, "TRICASTIN 3": 915.0, "TRICASTIN 4": 915.0, "FESSENHEIM 1": 0.0, "FESSENHEIM 2": 0.0} # --------------------- INITIAL DATA CLEANING FOR MONGO DATA ------------------------ # # # Create a DataFrame # mongo_data = mongo_unavs_call(usr_start_date, usr_end_date, past_date) # mongo_data = get_mongodb_data(usr_start_date, usr_end_date, past_date) # print(mongo_db_data) mongo_df = pd.DataFrame(mongo_db_data) # the five columns you care about _optional = { "updated_date", "type", "production_type", "unit", "status", } # see which of those actually exist present = set(mongo_df.columns) & _optional if _optional.issubset(mongo_df.columns): # 0. first, pick the columns you know exist, plus the always‑present ones cols = [ "identifier", "version", "message_id", "values", "publication_date", "unavailability_type", "fuel_type", "affected_asset_or_unit_name", "affected_asset_or_unit_installed_capacity", "event_status" ] + list(_optional) mongo_df = mongo_df[cols] # 1. normalize “unit” unit_expanded = pd.json_normalize(mongo_df["unit"]) mongo_df_2 = pd.concat([mongo_df.drop(columns=["unit"]), unit_expanded], axis=1) # 2. normalize the first element of “values” mongo_df_2["values_first"] = ( mongo_df_2["values"] .apply(lambda lst: lst[0] if isinstance(lst, list) and lst else {}) ) values_expanded = pd.json_normalize(mongo_df_2["values_first"]) mongo_df_2 = pd.concat( [mongo_df_2.drop(columns=["values", "values_first"]), values_expanded], axis=1 ) # 3. coalesce and drop old cols mongo_df_2["fuel_type"] = mongo_df_2["fuel_type"].combine_first(mongo_df_2["production_type"]) mongo_df_2["publication_date"] = mongo_df_2["publication_date"].combine_first(mongo_df_2["updated_date"]) mongo_df_2["event_status"] = mongo_df_2["event_status"].combine_first(mongo_df_2["status"]) mongo_df_2["affected_asset_or_unit_installed_capacity"] = ( mongo_df_2["affected_asset_or_unit_installed_capacity"] .combine_first(mongo_df_2["installed_capacity"]) ) mongo_df_2["affected_asset_or_unit_name"] = ( mongo_df_2["affected_asset_or_unit_name"] .combine_first(mongo_df_2["name"]) ) mongo_df_2["unavailability_type"] = ( mongo_df_2["unavailability_type"] .combine_first(mongo_df_2["type"].iloc[:, 0]) ) drop_cols = [ "production_type", "updated_date", "status", "installed_capacity", "name", "type", "eic_code", ] # only drop those that are actually there drop_cols = [c for c in drop_cols if c in mongo_df_2.columns] mongo_df_2 = mongo_df_2.drop(columns=drop_cols) # now mongo_df_2 is your final else: # at least one of the required columns is missing: # present contains the ones you did find missing = _optional - present print(f"Skipping normalize process because these columns are missing: {missing}") mongo_df_2 = mongo_df.copy() # or however you want to proceed mongo_df_2["values_first"] = mongo_df_2["values"].apply( lambda lst: lst[0] if isinstance(lst, list) and len(lst) > 0 else {} ) # 2. Normalize that dict into separate columns values_expanded = pd.json_normalize(mongo_df_2["values_first"]) # e.g. this produces columns like “start_date”, “end_date”, etc. # 3. Concatenate back and drop the originals mongo_df_2 = pd.concat( [ mongo_df_2.drop(columns=["values", "values_first", "start_date", "end_date"]), values_expanded ], axis=1 ) # Convert the date columns to datetime objects for col in ["publication_date", "start_date", "end_date"]: mongo_df_2[col] = pd.to_datetime(mongo_df_2[col], utc=True) # # Now convert everything to French time (CET/CEST): # for col in ["publication_date", "start_date", "end_date"]: # mongo_df_2[col] = mongo_df_2[col].dt.tz_convert("Europe/Paris") # mongo_df_2 = mongo_df_2.drop_duplicates(subset='identifier', keep='first') mongo_df_2['version'] = mongo_df_2['version'].astype(float) # Sort by identifier and version to ensure the latest version is at the top # Method 1: Use groupby + idxmax to pick the row with the largest version per identifier idx = mongo_df_2.groupby("identifier")["version"].idxmax() mongo_df_2 = mongo_df_2.loc[idx].reset_index(drop=True) mongo_df_2 = mongo_df_2[mongo_df_2['event_status'] != 'DISMISSED'] # Create the final dataframe final_df = pd.DataFrame() # Create the date column, with date range from start_date to end_date in daily granularity final_df['Date'] = pd.date_range(start=usr_start_date, end=usr_end_date, freq='D') final_df['Date'] = [ts.strftime("%Y-%m-%d") for ts in final_df['Date']] # For each plant create a new column with the plant name for plant, capacity in plants_metadata.items(): # Create a new column for each plant final_df[plant] = np.nan # Initialize with zeros mongo_df_3 = mongo_df_2.copy() dates_of_interest = list(pd.date_range(start=usr_start_date, end=usr_end_date, freq="D")) # Now convert each Timestamp → “YYYY-MM-DD” string: dates_of_interest = [ts.strftime("%Y-%m-%d") for ts in dates_of_interest] mongo_df_3['start_day'] = mongo_df_3['start_date'].dt.day mongo_df_3['start_hour'] = mongo_df_3['start_date'].dt.hour mongo_df_3['start_minute'] = mongo_df_3['start_date'].dt.minute mongo_df_3['end_day'] = mongo_df_3['end_date'].dt.day mongo_df_3['end_hour'] = mongo_df_3['end_date'].dt.hour mongo_df_3['end_minute'] = mongo_df_3['end_date'].dt.minute # mongo_df_3 = mongo_df_3.sort_values(by=['publication_date'], ascending=False) mongo_df_3 = mongo_df_3.sort_values(by=['publication_date']) # results_plants = {plant_name: {date: {"available_capacity": power, "publication_date": pd.to_datetime("1970-01-01", utc=True)} for date in dates_of_interest} # for plant_name, power in plants_metadata.items()} results_plants = {plant_name: {date: {"available_capacity": power, "publication_date": pd.to_datetime("1970-01-01", utc=True)} for date in dates_of_interest} for plant_name, power in plants_metadata.items()} for row in mongo_df_3.itertuples(): # Get the start and end dates for the unavailability row_start_date = str(row.start_date.date()) row_end_date = str(row.end_date.date()) # Get the plant name and capacity plant_name = row.affected_asset_or_unit_name plant_capacity = plants_metadata.get(plant_name, 0) # Default to 0 if not found results_current_plant = results_plants[plant_name] power_unavailability = row.available_capacity publication_date_unav = row.publication_date for day in dates_of_interest: # percentage_of_day = results_current_plant[day]["percentage_of_day"] if row_start_date <= day <= row_end_date: # Check if the day is already updated with a later (more recent) update_date; by sorting the DataFrame by publication_date, # we ensure that the latest unavailability is applied # Get the percentage of day that the plant is unavailable # if day in final_df['Date'] and pd.notna(final_df.loc[final_df['Date'] == day, plant_name]).any(): if (day in results_current_plant) and (publication_date_unav <= results_current_plant[day]["publication_date"]): # If the plant's capacity for that day is already set, skip to the next day continue # The unavailability starts and ends on the same day if row_start_date == day and day == row_end_date: percentage_of_day = (row.end_hour * 60 + row.end_minute - row.start_hour * 60 - row.start_minute) / (24 * 60) # results_current_plant[day]["percentage_of_day"] += percentage_of_day # power_of_day = percentage_of_day * row.available_capacity + (1 - percentage_of_day) * plant_capacity # final_df.loc[final_df['Date'] == day, plant_name] = power_of_day # The unavailability starts on the current day but ends on a later day elif row_start_date == day and day < row_end_date: percentage_of_day = (24 * 60 - (row.start_hour * 60 + row.start_minute)) / (24 * 60) # results_current_plant[day]["percentage_of_day"] += percentage_of_day # power_of_day = percentage_of_day * row.available_capacity + (1 - percentage_of_day) * plant_capacity # final_df.loc[final_df['Date'] == day, plant_name] = power_of_day # # The unavailability starts on a previous day and ends on the current day elif row_end_date == day and row_start_date < day: percentage_of_day = (row.end_hour * 60 + row.end_minute) / (24 * 60) # results_current_plant[day]["percentage_of_day"] += percentage_of_day # power_of_day = percentage_of_day * row.available_capacity + (1 - percentage_of_day) * plant_capacity # final_df.loc[final_df['Date'] == day, plant_name] = power_of_day else: # The unavailability starts on a previous day and ends on a later day percentage_of_day = 1 # power_of_day = percentage_of_day * row.available_capacity + (1 - percentage_of_day) * plant_capacity # final_df.loc[final_df['Date'] == day, plant_name] = power_of_day power_of_day = percentage_of_day * power_unavailability + (1 - percentage_of_day) * plant_capacity # Update the available_capacity for the day only if it's not already updated with a later update_date if (day not in results_current_plant): results_current_plant[day] = {"available_capacity": power_of_day, "publication_date": publication_date_unav} elif (day in results_current_plant) and (publication_date_unav > results_current_plant[day]["publication_date"]) \ and (power_of_day < results_current_plant[day]['available_capacity']): # results_current_plant[day]["available_capacity"] *= power_of_day # results_current_plant[day]["publication_date"] = publication_date_unav results_current_plant[day] = {"available_capacity": power_of_day, "publication_date": publication_date_unav} else: continue output_results = {} for plant, plant_data in results_plants.items(): available_capacity_per_day = {str(date): data["available_capacity"] for date, data in plant_data.items()} output_results[plant] = available_capacity_per_day add_total(output_results) output_results = {plant: {str(date): power for date, power in plant_data.items()} for plant, plant_data in output_results.items()} output_results = pd.DataFrame(output_results) # ------------------------------------------------- # Calculate the average of each column excluding the last row averages = output_results.iloc[:-1, :].mean() # Replace the last row with the calculated averages output_results.iloc[-1, :] = averages output_results = output_results.to_dict() def turn_total_row_to_avg(data): # Replace the last key of each dictionary with 'Averages' for key, value in data.items(): last_key = list(value.keys())[-1] value['Averages'] = value.pop(last_key) turn_total_row_to_avg(output_results) json_data = json.dumps(output_results) # print(json_data) return json_data # ------------------------------------------------- # @st.cache_data def get_mongodb_data(start_date, end_date, past_date): database_data = mongo_unavs_call(start_date, end_date, past_date) return database_data # @st.cache_data def get_nucmonitor_data(start_date, end_date, past_date): mongo = get_mongodb_data(start_date, end_date, past_date) response_nucmonitor = nuc_monitor(start_date, end_date, past_date, mongo) # nucmonitor_data = response_nucmonitor.json() # nucmonitor_json = json.loads(nucmonitor_data) # print(response_nucmonitor) df = pd.read_json(response_nucmonitor) return df # @st.cache_data def get_photodate_data(start_date, end_date, past_date): mongo = get_mongodb_data(start_date, end_date, past_date) response_nucmonitor = nuc_monitor(start_date, end_date, past_date, mongo) # nucmonitor_data = response_nucmonitor.json() # nucmonitor_json = json.loads(nucmonitor_data) # print(response_nucmonitor) df = pd.read_json(response_nucmonitor) return df def run_app(): st.title("Nucmonitor App") # Get user input (e.g., dates) start_date = st.date_input("Start Date") end_date = st.date_input("End Date") past_date = st.date_input("Cutoff Date") # winter_date = st.date_input("Winter Cutoff Date") current_date = datetime.datetime.now() with st.form("nucmonitor_form"): submitted = st.form_submit_button("Get Nucmonitor") if not submitted: st.write("Form not submitted") else: st.write("Data received from Flask:") df_nucmonitor = get_nucmonitor_data(start_date, end_date, current_date) df_photo_date = get_photodate_data(start_date, end_date, past_date) # df_winter_date = get_nucmonitor_data(start_date, end_date, winter_date) current_date_str = str(current_date.strftime('%Y-%m-%d')) past_date_str = str(past_date.strftime('%Y-%m-%d')) st.write(f"Current View Forecast at {current_date_str} (MW)") st.write(df_nucmonitor) # Display DataFrame st.write(f"Past View Forecast at {past_date_str}") st.write(df_photo_date) # Get info on current forecast Nucmonitor st.write(f"Total Energy per Day at Current View Forecast {current_date_str} (MW)") # Remove the final row 'Total' df_nucmonitor_2 = df_nucmonitor.iloc[:-1, :] # Get the last column df_nucmonitor_2 = df_nucmonitor_2.iloc[:, -1] # print(df_nucmonitor_2) st.write(df_nucmonitor_2) # Get info on past date forecast Nucmonitor st.write(f"Total Energy per Day at Past View Forecast {past_date_str} (MW)") # Remove the final row 'Total' df_photo_date_2 = df_photo_date.iloc[:-1, :] # Get the last column df_photo_date_2 = df_photo_date_2.iloc[:, -1] # print(df_photo_date_2) st.write(df_photo_date_2) # --------------------------------- AVERAGE EXPECTED AVAILABILITY M-1 M M+1 M+2 PIPELINE --------------------------------- # # Create a Table that displays the forecast of each dataframe total for two months before date and two months after # Filter dates for two months before and after the current date # Define date ranges # I am under the impression that I will need to use past_date for the offset # two_months_before = (current_date - pd.DateOffset(months=2)).strftime('%Y-%m') # one_month_before = (current_date - pd.DateOffset(months=1)).strftime('%Y-%m') # one_month_after = (current_date + pd.DateOffset(months=1)).strftime('%Y-%m') # two_months_after = (current_date + pd.DateOffset(months=2)).strftime('%Y-%m') two_months_before = (current_date - pd.DateOffset(months=2)).strftime('%Y-%m') one_month_before = (current_date - pd.DateOffset(months=1)).strftime('%Y-%m') one_month_after = (current_date + pd.DateOffset(months=1)).strftime('%Y-%m') two_months_after = (current_date + pd.DateOffset(months=2)).strftime('%Y-%m') # Assuming df is the DataFrame containing the date index and the 'Total' column # # Convert the index to datetime if it's not already # df_nucmonitor_2.index = pd.to_datetime(df_nucmonitor_2.index) # df_photo_date_2.index = pd.to_datetime(df_photo_date_2.index) # # Calculate monthly averages with date in yyyy-mm format # monthly_average_nucmonitor = df_nucmonitor_2.resample('M').mean() # monthly_average_photo_date = df_photo_date_2.resample('M').mean() # Convert the index to datetime if it's not already df_nucmonitor_2.index = pd.to_datetime(df_nucmonitor_2.index) df_photo_date_2.index = pd.to_datetime(df_photo_date_2.index) # Calculate monthly averages with date in yyyy-mm format monthly_average_nucmonitor = df_nucmonitor_2.resample('ME').mean() monthly_average_nucmonitor.index = monthly_average_nucmonitor.index.strftime('%Y-%m') monthly_average_photo_date = df_photo_date_2.resample('ME').mean() monthly_average_photo_date.index = monthly_average_photo_date.index.strftime('%Y-%m') # print(monthly_average_nucmonitor) # print(monthly_average_nucmonitor.index) # print(len(monthly_average_nucmonitor.index) < 5) if (len(monthly_average_nucmonitor.index) < 5) or (two_months_before not in monthly_average_nucmonitor.index or two_months_after not in monthly_average_nucmonitor.index): df_display_normal_bool = False else: # print(two_months_before, one_month_before, current_date.strftime('%Y-%m'), one_month_after, two_months_after) # Filter DataFrames based on date ranges df_nucmonitor_filtered = monthly_average_nucmonitor[ (monthly_average_nucmonitor.index == two_months_before) | (monthly_average_nucmonitor.index == one_month_before) | (monthly_average_nucmonitor.index == current_date.strftime('%Y-%m')) | (monthly_average_nucmonitor.index == one_month_after) | (monthly_average_nucmonitor.index == two_months_after) ] df_photo_date_filtered = monthly_average_photo_date[ (monthly_average_photo_date.index == two_months_before) | (monthly_average_photo_date.index == one_month_before) | (monthly_average_photo_date.index == current_date.strftime('%Y-%m')) | (monthly_average_photo_date.index == one_month_after) | (monthly_average_photo_date.index == two_months_after) ] # Display the filtered DataFrames st.write(f"Forecast at {current_date_str} (MW)") st.write(df_nucmonitor_filtered) st.write(f"Forecast at {past_date_str} (MW)") st.write(df_photo_date_filtered) current_forecast_update = df_nucmonitor_filtered.tolist() past_forecast_update = df_photo_date_filtered.tolist() delta = [current - past for current, past in zip(current_forecast_update, past_forecast_update)] # print('Dates:', [two_months_before, one_month_before, current_date.strftime('%Y-%m'), one_month_after, two_months_after]) # print(f"Forecast update {current_date_str}", current_forecast_update) # print(f"Forecast update {past_date_str}", past_forecast_update,) # print('Delta', delta) # Create a DataFrame for display data_avg_expected_normal = { 'Dates': [two_months_before, one_month_before, current_date.strftime('%Y-%m'), one_month_after, two_months_after], f"Forecast update {current_date_str} (MW)": current_forecast_update, f"Forecast update {past_date_str} (MW)": past_forecast_update, 'Delta': delta } df_display_normal_bool = True # --------------------------------- AVERAGE EXPECTED AVAILABILITY M-1 M M+1 M+2 PIPELINE --------------------------------- # # --------------------------------- AVERAGE EXPECTED AVAILABILITY WINTER PIPELINE --------------------------------- # # Create a Table that displays the forecast of each dataframe for the Winter months (Nov, Dec, Jan, Feb, Mar) # Create a table that gets the forecast for winter. This involves creating a new dataframe with # only the winter months with the total of each day, and another dataframe with the average of each month. Each month # included will only be 20xx-11, 12, and 20xx+1-01, 02, 03 # Define date ranges for winter months # winter_start_date = current_date.replace(month=11, day=1) # winter_end_date = (current_date.replace(year=current_date.year+1, month=3, day=31)) winter_start = f"{current_date.year}-11" winter_end = f"{current_date.year+1}-03" winter_start_str = str(winter_start) winter_end_str = str(winter_end) # print("winter_start_str", winter_start) # print("winter_end_str", winter_end) # print("monthly_average_nucmonitor.index", monthly_average_nucmonitor.index) # print(monthly_average_nucmonitor.index == winter_start) # print(monthly_average_nucmonitor.index == winter_end) if monthly_average_nucmonitor.index.any() != winter_start or monthly_average_nucmonitor.index.any() != winter_end: df_display_winter_bool = False else: # Filter DataFrames based on winter date range df_nucmonitor_winter = monthly_average_nucmonitor[(monthly_average_nucmonitor.index >= winter_start_str) & (monthly_average_nucmonitor.index <= winter_end_str)] df_photo_date_winter = monthly_average_photo_date[(monthly_average_photo_date.index >= winter_start_str) & (monthly_average_photo_date.index <= winter_end_str)] # Display the forecast DataFrames for winter st.title("Forecast for Winter Months") st.write(f"Forecast for {current_date.year}-{current_date.year+1} (Nov, Dec, Jan, Feb, Mar)") st.write("Nucmonitor Forecast:") st.write(df_nucmonitor_winter) st.write("Photo Date Forecast:") st.write(df_photo_date_winter) current_winter_forecast_update = df_nucmonitor_winter.tolist() past_winter_forecast_update = df_photo_date_winter.tolist() winter_delta = [current - past for current, past in zip(current_winter_forecast_update, past_winter_forecast_update)] # print("current_winter_forecast_update:", current_winter_forecast_update) # print("past_winter_forecast_update:", past_winter_forecast_update) # Create a DataFrame for display data_avg_expected_winter = { 'Dates': [f'Nov-{current_date.year}', f'Dec-{current_date.year}', f'Jan-{current_date.year+1}', f'Feb-{current_date.year+1}', f'Mar-{current_date.year+1}'], f"Forecast update {current_date_str}": current_winter_forecast_update, f"Forecast update {past_date_str}": past_winter_forecast_update, 'Delta': winter_delta } # print(data_avg_expected_winter) df_display_winter_bool = True # --------------------------------- AVERAGE EXPECTED AVAILABILITY WINTER PIPELINE --------------------------------- # # --------------------------------- VISUALIZE --------------------------------- # if df_display_normal_bool: df_display_normal = pd.DataFrame(data_avg_expected_normal) # Display the DataFrame as a horizontal table st.write("Table 1. Average expected availability on the French nuclear fleet (MW) - M-1, M, M+1, M+2, M+3") st.table(df_display_normal) if df_display_winter_bool: df_display_winter = pd.DataFrame(data_avg_expected_winter) st.write(f"Table 2. Average expected availability on the French nuclear fleet (MW) - Winter {winter_start}/{winter_end}") st.table(df_display_winter) # Line charts of the forecasts (need to combine them so they appear in the same chart) st.write("Current forecast (MW)") st.line_chart(df_nucmonitor_2) st.write("Previous forecast (MW)") st.line_chart(df_photo_date_2) # Create a new dataframe out of df_nucmonitor_2 call real_avail that contains df_nucmonitor_2 up until current_date # Slice the DataFrame to include data up until current_date real_avail = df_nucmonitor_2.loc[df_nucmonitor_2.index <= current_date_str] # Winter forecast still not the correct one, this is just a placeholder # winter_forecast = df_nucmonitor_2.loc[(df_nucmonitor_2.index >= winter_start_date) & (df_nucmonitor_2.index <= winter_end_date)] # Optionally, if you want to reset the index # real_avail = real_avail.reset_index() # print(real_avail) st.write("Observed Historical Availability (MW)") st.line_chart(real_avail) # Combine dataframes # combined_df = pd.concat([df_nucmonitor_2, df_photo_date_2, real_avail, winter_forecast], axis=1) combined_df = pd.concat([df_nucmonitor_2, df_photo_date_2, real_avail], axis=1) # combined_df.columns = [f'Forecast {current_date_str}', f'Forecast {past_date_str}', 'Observed Historical Availability', f'Winter forecast {winter_start}/{winter_end}'] combined_df.columns = [f'Forecast {current_date_str} (MW)', f'Forecast {past_date_str} (MW)', 'Observed Historical Availability (MW)'] # print(combined_df) st.write(f"Graph 1. {start_date} to {end_date} (MW)") st.line_chart(combined_df) # Add a download button # Create a BytesIO object to hold the Excel data excel_buffer = io.BytesIO() current_datetime = datetime.datetime.now() current_year = current_datetime.strftime('%Y') current_month = current_datetime.strftime('%m') current_day = current_datetime.strftime('%d') current_hour = current_datetime.strftime('%H') current_minute = current_datetime.strftime('%M') current_second = current_datetime.strftime('%S') # Save the DataFrame to the BytesIO object as an Excel file df_nucmonitor.to_excel(excel_buffer, index=True) # Set the cursor position to the beginning of the BytesIO object excel_buffer.seek(0) # Provide the BytesIO object to the download button download_button = st.download_button( label="Download Excel", data=excel_buffer, file_name=f"nucmonitor_data_{current_year}-{current_month}-{current_day}-h{current_hour}m{current_minute}s{current_second}.xlsx", mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", ) if __name__ == '__main__': run_app()