Added files

Dockerfile

@@ -0,0 +1,12 @@
+
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,679 @@
+import pandas as pd
+import numpy as np
+from flask import Flask, jsonify, request
+from flask_restx import Api, Resource, Namespace
+# from flask_httpauth import HTTPBasicAuth
+import requests
+import base64
+import json
+import datetime
+from calendar import monthrange
+import pymongo
+from mongoengine import StringField, ListField, DateTimeField, DictField
+
+"""
+This script creates an api that connects to the MongoDB database. This api will
+eventually allow connection between the database and the frontend
+"""
+# Connect to MongoDB
+# For some reason none of this works when im connected to VPN
+
+
+app = Flask(__name__)
+api = Api(app, version='1.0',
+          title='Haya Energy NucPy API',
+          description="""
+        API endpoints used to communicate NucPy
+        with MongoDB
+        """,
+          contact="Diego",
+          endpoint="/nucpy/v1")
+
+
+def mongo_unavs_call(user_input_start_date, user_input_end_date, user_input_photo_date, user_input_past_date):
+    # 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"
+    )
+
+    db = client["data"]
+    collection = db["unavs"]
+
+    start_date = f"{user_input_start_date}T00:00:00"
+    end_date = f"{user_input_end_date}T23:59:59"
+    
+    pipeline = [
+        {
+            "$unwind": "$results"
+        },
+        {
+            "$unwind": "$results.generation_unavailabilities"
+        },
+        {
+            "$match": {
+                "results.generation_unavailabilities.production_type": "NUCLEAR",
+                "results.generation_unavailabilities.start_date": {"$lte": end_date},
+                "results.generation_unavailabilities.end_date": {"$gte": start_date},
+                "results.generation_unavailabilities.updated_date": {"$lte": end_date}
+            }
+        },
+        {
+            "$project": {
+                "_id": 0,
+                "generation_unavailabilities": "$results.generation_unavailabilities"
+            }
+        }
+    ]
+
+    result = collection.aggregate(pipeline)
+
+    return list(result)
+
+# --------------------------------------------------------------------------------------- #
+
+# 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
+# --------------------------------------------------------------------------------------- #
+
+# The idea of this function is to sum the total availability for each day of interest
+# This is already done in the Excel so it might be useful to check
+# 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
+
+# --------------------------------------------------------------------------------------- #
+
+# 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):
+    # This should be changed in the case of getting a past_photo because many of the rows that are relevant for that 
+    # past photo will not be ACTIVE anymore.
+    # unav_status = ['ACTIVE', 'INACTIVE']
+    # This could also be changed. Currently it means that if we call the API with start_date=01/01/2023 and end_date=01/02/2023,
+    # it will return all the records of unavailabilities that have been updated between the two dates.
+    # date_type = 'UPDATED_DATE'
+    # date_type APPLICATION_DATE gets all unavailabilities with predictions in the defined dates, so that 
+    # we can get an unavailability that has updated_date outside the defined dates for start_date and 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
+    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()
+
+    # 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
+
+# --------------------------------------------------------------------------------------- #
+
+
+# this function does the proper analysis of the data
+# It takes the user, password, host, to connect to the mongodb database and get
+# the data to clean from the database from database and collection
+# Create a condition that makes it so it only takes the ACTIVE when nucmonitor, and 
+# all (INACTIVE, ACTIVE) when photo_date
+# nuc_monitor will always take the photo_date and past_date as inputs, even when photo_date == False. In case False, past_date == 0 or None
+def nuc_monitor(rte_data, mongo_json_data, usr_start_date, usr_end_date, photo_date, past_date):
+    # # Slightly changed metadata to fit the data from the RTE API: ST-LAURENT B 2 --> ST LAURENT 2, ....
+
+    # --------------------------------------------- #
+    # photo_date = False
+
+    # file_path = "/Users/diegomarroquin/HayaEnergy/data/plants_metadata.json"
+
+    # with open(file_path, "r") as file:
+    #     plants_metadata = json.load(file)
+    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, "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": 880.0, "FESSENHEIM 2": 880.0}
+
+
+    # Get raw data from database and the RTE
+    # oauth = get_oauth()
+    
+
+    # --------------------- INITIAL DATA CLEANING FOR RTE DATA ------------------------ #    
+    unav_API = rte_data.json()
+    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 ------------------------ #    
+
+
+
+    mongo_data = mongo_json_data.json()
+
+        # Specify the file path
+    file_path = "/Users/diegomarroquin/HayaEnergy/Nucmonitor_MVP/NucPy_v0.2/testing/test_data3.txt"
+
+    # Open the file in write mode
+    with open(file_path, 'w') as file:
+        for item in mongo_data:
+            file.write("%s" % item)
+
+    # # Create a DataFrame
+    mongo_df = pd.DataFrame(mongo_data)
+
+    # Unpack the dictionaries into separate columns
+    mongo_df_unpacked = pd.json_normalize(mongo_df['generation_unavailabilities'])
+
+    # Concatenate the unpacked columns with the original DataFrame
+    mongo_df_result = pd.concat([mongo_df, mongo_df_unpacked], axis=1)
+
+    # Drop the original column
+    mongo_df_result.drop(columns=['generation_unavailabilities'], inplace=True)
+    mongo_df_columns = mongo_df_result.columns
+    print(mongo_df_columns)
+    print(mongo_df_result)
+    print(mongo_df_result["values"])
+    # # Unpack values column
+    # # mongo_df2 = mongo_df_result.copy().apply(unpack_values, axis=1)
+    # mongo_df_values_unpacked = pd.json_normalize(mongo_df_result['values'])
+    # mongo_df2 = pd.concat([mongo_df_result, mongo_df_values_unpacked], axis=1)
+    # print(mongo_df2.columns)
+    # print(mongo_df2)
+    # # mongo_df2 = pd.concat([mongo_df_result, pd.json_normalize(mongo_df_result['values'])], axis=1)
+    # # mongo_df2 = pd.concat([mongo_df2, pd.json_normalize(mongo_df2['unit'])], axis=1)
+    # # mongo_df2 = mongo_df.copy().apply(unpack_values, axis=1)
+    # # mongo_df2 = mongo_df_result.copy()
+    # mongo_df2.drop(columns=["values"], inplace=True)
+    # mongo_df2.drop(0, axis=1, inplace=True)
+    # Unpack values using apply() and lambda functions
+    mongo_df_result['start_date'] = mongo_df_result['values'].apply(lambda x: x[0]['start_date'])
+    mongo_df_result['end_date'] = mongo_df_result['values'].apply(lambda x: x[0]['end_date'])
+    mongo_df_result['available_capacity'] = mongo_df_result['values'].apply(lambda x: x[0]['available_capacity'])
+    mongo_df_result['unavailable_capacity'] = mongo_df_result['values'].apply(lambda x: x[0]['unavailable_capacity'])
+    print(mongo_df_result)
+    print(mongo_df_result.columns)
+    # Drop the original 'values' column
+    mongo_df_result.drop('values', axis=1, inplace=True)
+    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)
+
+# --------------------------- HERE IS THE CHANGE TO GET ONLY ACTIVE OR ACTIVE AND INACTIVE --------------------------- #
+    # start_date_str = usr_start_date.strftime("%Y-%m-%d")
+    start_date_str = usr_start_date
+    # end_date_str = usr_end_date.strftime("%Y-%m-%d")
+    end_date_str = usr_end_date
+    current_datetime = datetime.datetime.now()
+    current_datetime_str = current_datetime.strftime("%Y-%m-%d")
+
+    if photo_date == True:
+        nuclear_unav = merged_df.copy()[(merged_df.copy()["production_type"] == "NUCLEAR") & (merged_df.copy()["updated_date"] <= past_date)]
+        photo_date = True
+    else: # need to add updated_date as a conditional to get the newest for that day
+        nuclear_unav = merged_df.copy()[(merged_df.copy()["production_type"] == "NUCLEAR") & (merged_df.copy()["updated_date"] <= end_date_str)]
+
+# --------------------------- HERE IS THE CHANGE TO GET ONLY ACTIVE OR ACTIVE AND INACTIVE --------------------------- #
+
+    # --------------------- SECOND DATA CLEANING ------------------------ #    
+    # This filter should take only the most recent id and discard the rest
+
+    # Sort by updated date
+    sorted_df = nuclear_unav.copy().sort_values(by='updated_date')
+
+    sorted_df = sorted_df.copy().reset_index(drop=True)
+
+    # Filter to get identifiers
+    filtered_id_df = sorted_df.copy()
+    filtered_id_df.drop_duplicates(subset='identifier', keep='last', inplace=True)
+    filtered_id_df = filtered_id_df.copy().reset_index(drop=True)
+
+
+    # This filter should take all the dates with unavs that include days with unavs in the range of the start and end date
+
+    filtered_df = filtered_id_df.copy()[(filtered_id_df.copy()['start_date'] <= end_date_str) & (filtered_id_df.copy()['end_date'] >= start_date_str)]
+
+    # Standardize datetime in dataframe
+    filtered_df2 = filtered_df.copy() # This code will just standardize datetime stuff
+    filtered_df2['creation_date'] = pd.to_datetime(filtered_df2['creation_date'], utc=True)
+    filtered_df2['updated_date'] = pd.to_datetime(filtered_df2['updated_date'], utc=True)
+    filtered_df2['start_date'] = pd.to_datetime(filtered_df2['start_date'], utc=True)
+    filtered_df2['end_date'] = pd.to_datetime(filtered_df2['end_date'], utc=True)
+
+    # Drop the duplicates
+    filtered_df3 = filtered_df2.copy().drop_duplicates()
+
+    # start_date_datetime = pd.to_datetime(start_date_str, utc=True)  # Remove timezone info
+    start_date_datetime = pd.Timestamp(start_date_str, tz='UTC')
+    # end_date_datetime = pd.to_datetime(end_date_str, utc=True)
+    end_date_datetime = pd.Timestamp(end_date_str, tz='UTC')
+
+    # Turn df into dict for json processing
+    filtered_unavs = filtered_df3.copy().to_dict(orient='records')
+
+    file_path = "/Users/diegomarroquin/HayaEnergy/Nucmonitor_MVP/NucPy_v0.2/testing/test_data4.txt"
+
+    # Open the file in write mode
+    with open(file_path, 'w') as file:
+        for item in filtered_unavs:
+            file.write("%s" % item)
+    results = {}
+
+    for unav in filtered_unavs:
+        plant_name = unav['name']
+        if plant_name in results:
+            # If the key is already in the dictionary, append unavailability to the list
+            results[plant_name].append({'status': unav['status'],
+                                        'id': unav['message_id'],
+                                        'creation_date': unav['creation_date'],
+                                        'updated_date': unav['updated_date'], 
+                                        'start_date': unav['start_date'], 
+                                        'end_date': unav['end_date'], 
+                                        'available_capacity': unav['available_capacity']})
+        else:
+            # if the key of the plant is not there yet, create a new element of the dictionary
+
+            # Get message_id instead of identifier, easier to identify stuff with it
+            results[plant_name] = [{'status': unav['status'],
+                                    'id': unav['message_id'],
+                                    'creation_date': unav['creation_date'],
+                                    'updated_date': unav['updated_date'], 
+                                    'start_date': unav['start_date'], 
+                                    'end_date': unav['end_date'], 
+                                    'available_capacity': unav['available_capacity']}]
+                        
+    # Custom encoder to handle datetime objects
+    class DateTimeEncoder(json.JSONEncoder):
+        def default(self, o):
+            if isinstance(o, datetime.datetime):
+                return o.isoformat()
+            return super().default(o)
+
+    results_holder = results
+
+    # Create new dict with each plant only having start_date less than user_end_date and an end_date greater than user_start_date
+    # should just be doing the same as above in the df for filtering only dates that inclued the start and end date
+    start_date = start_date_datetime.date()
+    end_date = end_date_datetime.date()
+    results_filtered = results_holder
+    for key, value in results_filtered.items():
+        filtered_values = []
+        for item in value:
+            item_start_date = item['start_date'].date()
+            item_end_date = item['end_date'].date()
+            identifier = item['id']
+            if item_start_date < end_date and item_end_date > start_date and identifier not in filtered_values:
+                filtered_values.append(item)
+        results_filtered[key] = filtered_values
+
+
+    sorted_results = results_filtered
+    # --------------------- SECOND DATA CLEANING ------------------------ #    
+
+# --------------------------- HERE IS THE FINAL PROCESS --------------------------- #
+
+    for key, value in sorted_results.items():
+        sorted_results[key] = sorted(value, key=lambda x: x['updated_date'])
+
+    results_sorted = sorted_results
+ 
+    dates_of_interest = [start_date] # We are creating a list of dates ranging from user specified start and end dates
+    date_plus_one = start_date
+
+    while date_plus_one < end_date:
+        date_plus_one = date_plus_one + datetime.timedelta(days=1)
+        dates_of_interest.append(date_plus_one) 
+        
+    # This is to standardize the datetimes. Without this, the datetime calculations for each power plant will not work
+    results_plants = {plant_name: {date: {"available_capacity": power, "updated_date": pd.to_datetime("1970-01-01", utc=True)} for date in dates_of_interest}
+                    for plant_name, power in plants_metadata.items()}
+
+
+    for plant, unavailabilities in results_sorted.items():
+
+        original_power = plants_metadata[plant]
+        # Get all the unavailabilities scheduled for the plant.
+        results_current_plant = results_plants[plant] 
+        
+        for unavailability in unavailabilities:
+            # For each unavailability, the resulting power, start and end datetime are collected. Need to collect updated_date
+            power_unavailability = unavailability["available_capacity"]
+            updated_date_unav = unavailability["updated_date"]
+            # The date comes as a string
+            start_datetime_unav = unavailability["start_date"]
+            end_datetime_unav = unavailability["end_date"]
+            start_date_unav = start_datetime_unav.date()  # Extract date part
+            end_date_unav = end_datetime_unav.date()      # Extract date part
+            
+            # For the current unavailability, we want to find which days it affects
+            for day in dates_of_interest: 
+
+                start_hour = start_datetime_unav.hour
+                start_minute = start_datetime_unav.minute
+                end_hour = end_datetime_unav.hour
+                end_minute = end_datetime_unav.minute
+
+                if start_date_unav <= day <= end_date_unav:
+                    # Check if the day is already updated with a later update_date
+                    if day in results_current_plant and updated_date_unav <= results_current_plant[day]["updated_date"]:
+                        continue  # Skip to the next loop if there is already information for a later update_date
+
+                    # Calculate the % of the day that the plant is under maintenance
+                    if start_date_unav == day and day == end_date_unav:
+                        # The unavailability starts and ends on the same day
+                        percentage_of_day = (end_hour * 60 + end_minute - start_hour * 60 - start_minute) / (24 * 60)
+                    elif start_date_unav == day:
+                        # The unavailability starts on the current day but ends on a later day
+                        percentage_of_day = (24 * 60 - (start_hour * 60 + start_minute)) / (24 * 60)
+                    elif day == end_date_unav:
+                        # The unavailability starts on a previous day and ends on the current day
+                        percentage_of_day = (end_hour * 60 + end_minute) / (24 * 60)
+                    else:
+                        # The unavailability covers the entire day
+                        percentage_of_day = 1
+
+                    # The average power of the day is calculated
+                    power_of_day = percentage_of_day * power_unavailability + (1 - percentage_of_day) * original_power
+
+                    # 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 or updated_date_unav > results_current_plant[day]["updated_date"]:
+                        results_current_plant[day] = {"available_capacity": power_of_day, "updated_date": updated_date_unav}
+
+
+    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
+
+    # print(output_results)
+    add_total(output_results)
+    print("Done")
+    # print(results_plants)
+    # Convert datetime key to string to store in mongodb
+    output_results = {plant: {str(date): power for date, power in plant_data.items()} for plant, plant_data in output_results.items()}
+    print(output_results)
+    # -------------------------------------------------
+    if photo_date == False:
+        # Store the results_plants in MongoDB
+        database_name = "data"  # Specify your database name
+        collection_name = "filtered"  # Specify your collection name
+        # mongo_store_data(output_results, database_name, collection_name)
+        # mongo_replace_data(results_plants_total, database_name, "filtered_excel")
+        # print("Data stored in database")
+        # mongo_append_data(results_plants, database_name, collection_name)
+        
+        # json_data = json.dumps(convert_to_json(output_results))
+        json_data = json.dumps(output_results)
+        print(json_data)
+        return json_data
+    else:
+        database_name = "data"  # Specify your database name
+        collection_name = "photo_date"  # Specify your collection name
+        # mongo_store_data(output_results, database_name, collection_name)
+
+        # json_data = json.dumps(convert_to_json(output_results))
+        json_data = json.dumps(output_results)
+        print(json_data)
+        return json_data
+    # -------------------------------------------------
+    return 
+
+
+# Namespaces
+
+# Get raw data stuff
+
+raw_ns = Namespace('raw', description='Raw Data', path='/nucpy/v1')
+api.add_namespace(raw_ns)
+
+@raw_ns.route('/raw', methods=["GET"])
+@raw_ns.doc(params= {"start_date": "Start date", "end_date": "end date", "photo_date": "True False", "past_date": "Cutoff date"})
+class Raw(Resource):
+    # @auth.login_required
+    def get(self):
+        # raw_data = merge_gridfs_files_to_json()
+        print("Applying request")
+        mongo_start_date = request.args.get("start_date")
+        mongo_end_date = request.args.get("end_date")
+        mongo_photo_date = request.args.get("photo_date")
+        mongo_past_date = request.args.get("past_date")
+        print("Getting raw_data")
+        raw_data = mongo_unavs_call(mongo_start_date, mongo_end_date, mongo_past_date, mongo_photo_date)
+        print("Returning raw_data")
+        print(raw_data)
+        return raw_data
+
+# Get RTE data
+
+rte_ns = Namespace('rte', description='RTE Data', path='/nucpy/v1')
+api.add_namespace(rte_ns)
+
+@rte_ns.route('/rte', methods=["GET"])
+# @rte_ns.doc(params= {"start_date": "Start date", "end_date": "end date"})
+class RTEDATA(Resource):
+    # @auth.login_required
+    def get(self):
+        rte_start_date = request.args.get("start_date")
+        rte_end_date = request.args.get("end_date")
+        print(rte_start_date)
+        print(rte_end_date)
+        # Process the user input and retrieve data
+        data = get_unavailabilities(rte_start_date, rte_end_date)
+
+        return data
+
+# Get processed data
+
+nucmonitor_ns = Namespace('nucmonitor', description='Nucmonitor', path='/nucpy/v1')
+api.add_namespace(nucmonitor_ns)
+
+@nucmonitor_ns.route('/nucmonitor', methods=['GET'])
+class Nucmonitor(Resource):
+    # @auth.login_required
+    def get(self):
+        # Retrieve input parameters from request.args
+        start_date = request.args.get("start_date")
+        end_date = request.args.get("end_date")
+        photo_date = request.args.get("photo_date")
+        past_date = request.args.get("past_date")
+
+        # Call the /rte endpoint to get RTE data
+        rte_data = self.get_rte_data(start_date, end_date)
+        print("Got RTE data")
+        print("Getting Mongo data")
+        mongo_data = self.get_mongo_data(start_date, end_date, photo_date, past_date)
+        print("Got Mongo data")
+        print(mongo_data)
+        # Process data using nuc_monitor
+        nucmonitor_response = nuc_monitor(rte_data, mongo_data, start_date, end_date, photo_date, past_date)
+        # print(nucmonitor_response)
+        return (nucmonitor_response)
+
+    def get_rte_data(self, start_date, end_date):
+        rte_url = "http://127.0.0.1:5000/nucpy/v1/rte"  # RTE endpoint URL
+        rte_params = {"start_date": start_date, "end_date": end_date}
+        rte_response = requests.get(rte_url, params=rte_params)
+        # rte_data = rte_response.json()
+        return rte_response
+        
+    def get_mongo_data(self, start_date, end_date, photo_date, past_date):
+        print("Getting url")
+        mongo_url = "http://127.0.0.1:5000/nucpy/v1/raw"  # Mongo endpoint URL
+        print("Getting params")
+        mongo_params = {"start_date": start_date, "end_date": end_date, "photo_date": photo_date, "past_date": past_date}
+        print("Getting request")
+        mongo_response = requests.get(mongo_url, params=mongo_params)
+        # mongo_data = mongo_response.json()
+        print("Returning response")
+        return mongo_response
+
+
+
+if __name__ == '__main__':
+    app.run('0.0.0.0')

requirements.txt

@@ -0,0 +1,18 @@
+Flask==2.2.3
+Flask==2.2.2
+Flask_HTTPAuth==4.7.0
+flask_restx==1.0.6
+flask_restx==1.1.0
+matplotlib==3.7.1
+mongoengine==0.26.0
+mongoengine==0.27.0
+numpy==1.24.3
+numpy==1.22.4
+numpy==1.25.2
+pandas==1.5.3
+pandas==2.0.3
+pymongo==4.3.3
+pymongo==4.4.1
+Requests==2.31.0
+streamlit==1.25.0
+streamlit==1.26.0