Test of no rte

.gitignore

@@ -1 +1,2 @@
-/app_with_api.py
+/app_with_api.py
+/app_with_rte.py

app.py

@@ -24,11 +24,12 @@ def mongo_unavs_call(user_input_start_date, user_input_end_date, user_input_past
     passw = "tN9XpCCQM2MtYDme"
     host = "nucmonitordata.xxcwx9k.mongodb.net"
     client = pymongo.MongoClient(
-        f"mongodb+srv://{user}:{passw}@{host}/?retryWrites=true&w=majority"
+        f"mongodb+srv://{user}:{passw}@{host}/?retryWrites=true&w=majority&connectTimeoutMS=5000"
     )
 
     db = client["data"]
-    collection = db["unavs"]
+    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"
@@ -56,9 +57,13 @@ def mongo_unavs_call(user_input_start_date, user_input_end_date, user_input_past
         }
     ]
 
-    result = collection.aggregate(pipeline)
+    result1 = list(collection_past_unavs.aggregate(pipeline))
+    result2 = list(collection_unavs.aggregate(pipeline))
+    
+    # Merge the two lists of JSON results
+    merged_result = result1 + result2
 
-    return list(result)
+    return merged_result
 
 # --------------------------------------------------------------------------------------- #
 
@@ -92,120 +97,7 @@ def add_total(data):
 
 # --------------------------------------------------------------------------------------- #
 
-# This file will simply connect to the rte and get the data directly from there
-
-# Function to create an authentication token. This token is then used in the HTTP requests to the API for authentication.
-# It is necessary to receive data from RTE.
-def get_oauth():
-    # ID from the user. This is encoded to base64 and sent in an HTTP request to receive the oauth token.
-    # This ID is from my account (RMP). However, another account can be created in the RTE API portal and get another ID.
-    joined_ID = '057e2984-edb3-4706-984b-9ea0176e74db:dc9df9f7-9f91-4c7a-910c-15c4832fb7bc'
-    b64_ID = base64.b64encode(joined_ID.encode('utf-8'))
-    b64_ID_decoded = b64_ID.decode('utf-8')
-    
-    # Headers for the HTTP request
-    headers = {'Content-Type': 'application/x-www-form-urlencoded',
-               'Authorization': f'Basic {b64_ID_decoded}'}
-    api_url = 'https://digital.iservices.rte-france.com/token/oauth/'
-    # Call to the API and if successful, the response will be 200.
-    response = requests.post(api_url, headers=headers)
-    
-    # When positive response, the token is retrieved
-    data = response.json()
-    oauth = data['access_token']
-    
-    return(oauth)
-
-# --------------------------------------------------------------------------------------- #
-
-# This function does severall calls to the RTE API (because maximum time between start_date and end_date is 1 month) 
-# the argument past_photo is a boolean (True, False) that indicates if we want to make a photo from the past or not
-# However, the past_photo part and past_date is not yet implemented.
-def get_unavailabilities(usr_start_date, usr_end_date):
-    oauth = get_oauth()
-    print("Get Oauth done")
-    date_type = 'APPLICATION_DATE'
-    
-    # Current year/month/day/hour/minute/second is calculated for the last call to the API. For instance, if today is 05/05/2023,
-    # the last call of the API will be from 01/05/2023 to 05/05/2023 (+current hour,minute,second). 
-    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')
-    
-    # Headers for the HTTP request
-    headers = {'Host': 'digital.iservices.rte-france.com',
-               'Authorization': f'Bearer {oauth}'
-        }
-    
-    # the responses object is where we are going to store all the responses from the API.
-    # Initially, current_datetime is included to know when we have called the API and all the
-    # individual results of the API (because each call is Maz 1 month) are stored in responses["results"]
-    responses = {"current_datetime": current_datetime.strftime("%m/%d/%Y, %H:%M:%S"),
-                 "results":[]
-        }
-
-    # --------------------------- HERE HAVE TO GET THE RANGE OF DATES FROM START AND END AND PUT THEM INTO LIST --------------------------- #
-    # Convert start_date and end_date to datetime objects
-    usr_start_date = str(usr_start_date)
-    usr_end_date = str(usr_end_date)
-    start_date_obj = datetime.datetime.strptime(usr_start_date, "%Y-%m-%d").date()
-    end_date_obj = datetime.datetime.strptime(usr_end_date, "%Y-%m-%d").date()
-    # start_date_obj = usr_start_date
-    # end_date_obj = usr_end_date
-    # Initialize lists to store years and months
-    years = []
-    months = []
-
-    # Generate the range of years and months
-    current_date = start_date_obj
-    while current_date <= end_date_obj:
-        years.append(current_date.year)
-        months.append(current_date.month)
-        current_date += datetime.timedelta(days=1)
-
-    # Remove duplicates from the lists
-    years = list(set(years))
-    months = list(set(months))
-    years.sort()
-    months.sort()
-    print(years)
-    print(months)
-   # --------------------------- HERE HAVE TO GET THE RANGE OF DATES FROM START AND END AND PUT THEM INTO LIST --------------------------- #
-
-    # Loop to call the API all the necessary times.
-    for i in range(len(years)):
-        for j in range(len(months)): 
-            # start_year and start_month of the current call to the API
-            start_year = years[i]
-            start_month = months[j]
-            # start_date is constructed. Now we only need to construct the end_date.
-            start_date = f'{start_year}-{start_month}-01T00:00:00%2B02:00'
-
-            if True:
-                # Calculate the number of days in the current month
-                _, num_days = monthrange(int(start_year), int(start_month))
-                end_date = f'{start_year}-{start_month}-{num_days}T23:59:59%2B02:00'
-                    
-                print(f'start date is {start_date}')
-                print(f'end date is {end_date}')
-                
-                # Call to the API
-                api_url = f'https://digital.iservices.rte-france.com/open_api/unavailability_additional_information/v4/generation_unavailabilities?date_type={date_type}&start_date={start_date}&end_date={end_date}'
-
-                response = requests.get(api_url, headers=headers)
-                json_response = response.json()
-                responses["results"].append(json_response)
-    # print(responses)
-    return responses
-
-# --------------------------------------------------------------------------------------- #
-
-
-def nuc_monitor(usr_start_date, usr_end_date, past_date, mongo_db_data, rte_data):
+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, 
@@ -223,44 +115,6 @@ def nuc_monitor(usr_start_date, usr_end_date, past_date, mongo_db_data, rte_data
                    "ST LAURENT 2": 915.0, "TRICASTIN 1": 915.0, "TRICASTIN 2": 915.0, "TRICASTIN 3": 915.0, 
                    "TRICASTIN 4": 915.0, "FESSENHEIM 1": 880.0, "FESSENHEIM 2": 880.0}
 
-    # --------------------- INITIAL DATA CLEANING FOR RTE DATA ------------------------ #  
-    # unav_API = rte_data.json()
-    # rte_stuff = get_unavailabilities(usr_start_date, usr_end_date)
-    # rte_stuff = get_rte_data(usr_start_date, usr_end_date)
-    unav_API = rte_data
-    # print(unav_API)
-    # Store the unavailabilities in a list
-    unavailabilities = []
-    print("Unav")
-    for unavailabilities_API in unav_API['results']:
-        try:
-            unavailabilities.extend(unavailabilities_API.get('generation_unavailabilities', []))
-        except:
-            print('There was an error')
-            # print(unavailabilities_API)
-    rte_df = pd.DataFrame(unavailabilities)
-
-
-    def unpack_values(row):
-        if isinstance(row["values"], list):
-            for key, value in row["values"][0].items():
-                row[key] = value
-        return row
-    # Apply the function to each row in the DataFrame
-    rte_df = rte_df.apply(unpack_values, axis=1)
-
-    # Drop the original "values" column
-    rte_df.drop("values", axis=1, inplace=True)
-
-    # Unpack the unit column
-    rte_df2 = pd.concat([rte_df, pd.json_normalize(rte_df['unit'])], axis=1)
-    rte_df2.drop('unit', axis=1, inplace=True)
-
-
-    rte_nuclear_unav = rte_df2[(rte_df2["production_type"] == "NUCLEAR")]
-
-    # --------------------- INITIAL DATA CLEANING FOR RTE DATA ------------------------ #    
-
 
     # --------------------- INITIAL DATA CLEANING FOR MONGO DATA ------------------------ #    
 
@@ -291,21 +145,12 @@ def nuc_monitor(usr_start_date, usr_end_date, past_date, mongo_db_data, rte_data
     mongo_df2 = mongo_df_result
     mongo_df2.rename(columns=lambda col: col.replace('unit.', ''), inplace=True)
 
-    
-
     # --------------------- INITIAL DATA CLEANING FOR MONGO DATA ------------------------ #   
 
     # Make the two dataframes have the same columns
     mongo_unavs = mongo_df2.copy()
     mongo_unavs.drop(columns="type", inplace=True)
 
-    rte_unavs = rte_nuclear_unav.copy()
-    rte_unavs.drop(columns="type", inplace=True)
-
-    # Merge dataframes
-    column_order = mongo_unavs.columns
-    # print(column_order)
-    merged_df = pd.concat([mongo_unavs[column_order], rte_unavs[column_order]], ignore_index=True)
     # merged_df['updated_date'] = merged_df['updated_date'].astype(str)
 
 # --------------------------- HERE IS THE CHANGE TO GET ONLY ACTIVE OR ACTIVE AND INACTIVE --------------------------- #
@@ -317,7 +162,7 @@ def nuc_monitor(usr_start_date, usr_end_date, past_date, mongo_db_data, rte_data
     past_date_str = str(past_date)
     current_datetime_str = current_datetime.strftime("%Y-%m-%d")
 
-    nuclear_unav = merged_df.copy()[(merged_df.copy()["production_type"] == "NUCLEAR") & (merged_df.copy()["updated_date"] <= past_date_str)]
+    nuclear_unav = mongo_unavs.copy()[(mongo_unavs.copy()["production_type"] == "NUCLEAR") & (mongo_unavs.copy()["updated_date"] <= past_date_str)]
 
     # if photo_date == True:
     #     nuclear_unav = merged_df.copy()[(merged_df.copy()["production_type"] == "NUCLEAR") & (merged_df.copy()["updated_date"] <= past_date_str)]
@@ -511,11 +356,7 @@ def nuc_monitor(usr_start_date, usr_end_date, past_date, mongo_db_data, rte_data
     return json_data
     # -------------------------------------------------
 
-@st.cache_data
-def get_rte_data(start_date, end_date):
-    rte_data = get_unavailabilities(start_date, end_date)
-    print(rte_data)
-    return rte_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)
@@ -524,8 +365,7 @@ def get_mongodb_data(start_date, end_date, past_date):
 @st.cache_data
 def get_nucmonitor_data(start_date, end_date, past_date):
     mongo = get_mongodb_data(start_date, end_date, past_date)
-    rte = get_rte_data(start_date, end_date)
-    response_nucmonitor = nuc_monitor(start_date, end_date, past_date, mongo, rte)
+    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)
@@ -540,18 +380,21 @@ def run_app():
     start_date = st.date_input("Start Date")
     end_date = st.date_input("End Date")
     past_date = st.date_input("Cutoff Date")
-    current_date = datetime.datetime.now()
+    # 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_nucmonitor_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("Nucmonitor")
@@ -584,81 +427,185 @@ def run_app():
 
         st.write(df_photo_date_2)
 
-        # # Create a Table that displays the forecast of each dataframe total for two months before date and two months after
-        # # Create a Table that displays the forecast of each dataframe for the Winter months (Nov, Dec, Jan, Feb, Mar)
-
-        # # Filter dates for two months before and after the current date
-        # # Define date ranges
-        # two_months_before = (current_date - pd.DateOffset(months=2)).strftime('%Y-%m-%d')
-        # one_month_before = (current_date - pd.DateOffset(months=1)).strftime('%Y-%m-%d')
-        # one_month_after = (current_date + pd.DateOffset(months=1)).strftime('%Y-%m-%d')
-        # two_months_after = (current_date + pd.DateOffset(months=2)).strftime('%Y-%m-%d')
-
-        # # Filter DataFrames based on date ranges
-        # df_nucmonitor_filtered = df_nucmonitor_2[
-        #     (df_nucmonitor_2.index == two_months_before) |
-        #     (df_nucmonitor_2.index == one_month_before) |
-        #     (df_nucmonitor_2.index == current_date_str) |
-        #     (df_nucmonitor_2.index == one_month_after) |
-        #     (df_nucmonitor_2.index == two_months_after)
-        # ]
-
-        # df_photo_date_filtered = df_photo_date_2[
-        #     (df_photo_date_2.index == two_months_before) |
-        #     (df_photo_date_2.index == one_month_before) |
-        #     (df_photo_date_2.index == current_date_str) |
-        #     (df_photo_date_2.index == one_month_after) |
-        #     (df_photo_date_2.index == two_months_after)
-        # ]
-
-        # # Display the filtered DataFrames
-        # st.write(f"Forecast update {current_date_str}")
-        # st.write(df_nucmonitor_filtered)
-        # st.write(f"Forecast update {past_date_str}")
-        # 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)]
-
-        # # Create a DataFrame for display
-        # data = {
-        #     'Dates': [two_months_before, one_month_before, current_date_str, one_month_after, two_months_after],
-        #     f"Forecast update {current_date_str}": current_forecast_update,
-        #     f"Forecast update {past_date_str}": past_forecast_update,
-        #     'Delta': delta
-        # }
-
-        # df_display = pd.DataFrame(data)
-
-        # # 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)
-
-
-        # # Line charts of the forecasts (need to combine them so they appear in the same chart)
-        # st.write("Current forecast")
-        # st.line_chart(df_nucmonitor_2)
-
-        # st.write("Previous forecast")
-        # st.line_chart(df_photo_date_2)
-        # # Create a new dataframe out of df_nucmonitor_2 call real_forecast that contains df_nucmonitor_2 up until current_date
-
-        # # Slice the DataFrame to include data up until current_date
-        # real_forecast = df_nucmonitor_2.loc[df_nucmonitor_2.index <= current_date_str]
-
-        # # Optionally, if you want to reset the index
-        # # real_forecast = real_forecast.reset_index()
-        # print(real_forecast)
-        # st.write("Real forecast")
-        # st.line_chart(real_forecast)
+# --------------------------------- 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
+        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('M').mean()
+        monthly_average_nucmonitor.index = monthly_average_nucmonitor.index.strftime('%Y-%m')
+
+        monthly_average_photo_date = df_photo_date_2.resample('M').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 update {current_date_str}")
+            st.write(df_nucmonitor_filtered)
+            st.write(f"Forecast update {past_date_str}")
+            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}": current_forecast_update,
+                f"Forecast update {past_date_str}": 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
         
-        # # Combine dataframes
-        # combined_df = pd.concat([df_nucmonitor_2, df_photo_date_2, real_forecast], axis=1)
-        # combined_df.columns = [f'Forecast {current_date_str}', f'Forecast {past_date_str}', 'Real Forecast']
+        # 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
 
-        # print(combined_df)
-        # st.write(f"Graph 1. {start_date} to {end_date}")
-        # st.line_chart(combined_df)
+# --------------------------------- 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")
+        st.line_chart(df_nucmonitor_2)
+
+        st.write("Previous forecast")
+        st.line_chart(df_photo_date_2)
+        # Create a new dataframe out of df_nucmonitor_2 call real_forecast that contains df_nucmonitor_2 up until current_date
+
+        # Slice the DataFrame to include data up until current_date
+        real_forecast = 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_forecast = real_forecast.reset_index()
+        print(real_forecast)
+        st.write("Real forecast")
+        st.line_chart(real_forecast)
+
+        # Combine dataframes
+        # combined_df = pd.concat([df_nucmonitor_2, df_photo_date_2, real_forecast, winter_forecast], axis=1)
+        combined_df = pd.concat([df_nucmonitor_2, df_photo_date_2, real_forecast], axis=1)
+
+        # combined_df.columns = [f'Forecast {current_date_str}', f'Forecast {past_date_str}', 'Real Forecast', f'Winter forecast {winter_start}/{winter_end}']
+        combined_df.columns = [f'Forecast {current_date_str}', f'Forecast {past_date_str}', 'Real Forecast']
+
+        print(combined_df)
+        st.write(f"Graph 1. {start_date} to {end_date}")
+        st.line_chart(combined_df)
 
         # # Set Nucmonitor as a dotted line until the current date