optimal time prediction now takes max percentage renewable

Author: shubhvjain

codegreen_core/tools/loadshift_time.py

@@ -24,7 +24,6 @@ def _get_energy_data(country, start, end):
     Check the country data file if models exists
     """
     energy_mode = Config.get("default_energy_mode")
-
     if Config.get("enable_energy_caching") == True:
         # check prediction is enabled : get cache or update prediction
         try:
@@ -43,6 +42,7 @@ def _get_energy_data(country, start, end):
                 forecast = energy(country, start, end, "forecast")
         elif energy_mode == "public_data":
             forecast = energy(country, start, end, "forecast")
+            # print(forecast)
         else:
             return None
         return forecast["data"]
@@ -53,8 +53,7 @@ def predict_now(
     estimated_runtime_hours: int,
     estimated_runtime_minutes: int,
     hard_finish_date: datetime,
-    criteria: str = "percent_renewable",
-    percent_renewable: int = 50,
+    criteria: str = "percent_renewable"
 ) -> tuple:
     """
     Predicts optimal computation time in the given location starting now
@@ -69,8 +68,6 @@ def predict_now(
     :type hard_finish_date: datetime
     :param criteria: Criteria based on which optimal time is calculated. Valid value "percent_renewable" or "optimal_percent_renewable"
     :type criteria: str
-    :param percent_renewable: The minimum percentage of renewable energy desired during the runtime
-    :type percent_renewable: int
     :return: Tuple[timestamp, message, average_percent_renewable]
     :rtype: tuple
     """
@@ -85,8 +82,7 @@ def predict_now(
                     energy_data,
                     estimated_runtime_hours,
                     estimated_runtime_minutes,
-                    percent_renewable,
-                    hard_finish_date,
+                    hard_finish_date
                 )
             else:
                 return _default_response(Message.ENERGY_DATA_FETCHING_ERROR)
@@ -104,7 +100,6 @@ def predict_optimal_time(
     energy_data: pd.DataFrame,
     estimated_runtime_hours: int,
     estimated_runtime_minutes: int,
-    percent_renewable: int,
     hard_finish_date: datetime,
     request_time: datetime = None,
 ) -> tuple:
@@ -114,7 +109,6 @@ def predict_optimal_time(
     :param energy_data: A DataFrame containing the energy data including startTimeUTC, totalRenewable,total,percent_renewable,posix_timestamp
     :param estimated_runtime_hours: The estimated runtime in hours
     :param estimated_runtime_minutes: The estimated runtime in minutes
-    :param percent_renewable: The minimum percentage of renewable energy desired during the runtime
     :param hard_finish_date: The latest possible finish time for the task.
     :param request_time: The time at which the prediction is requested. Defaults to None, then the current time is used. Assumed to be in local timezone
 
@@ -123,7 +117,7 @@ def predict_optimal_time(
     """
 
     granularity = 60  # assuming that the granularity of time series is 60 minutes
-
+    # print(percent_renewable)
     #  ============ data validation   =========
     if not isinstance(hard_finish_date, datetime):
         raise ValueError("Invalid hard_finish_date. it must be a datetime object")
@@ -133,6 +127,7 @@ def predict_optimal_time(
             raise ValueError("Invalid request_time. it must be a datetime object")
     if energy_data is None:
         return _default_response(Message.NO_DATA, request_time)
+    percent_renewable =  int(energy_data["percent_renewable"].max())  #assuming we want the max possible percent renewable 
     if percent_renewable <= 0:
         return _default_response(Message.NEGATIVE_PERCENT_RENEWABLE, request_time)
     if estimated_runtime_hours <= 0:

codegreen_core/utilities/config.py

@@ -13,7 +13,12 @@ class Config:
     config_data = None
     section_name = "codegreen"
     boolean_keys = {"enable_energy_caching", "enable_time_prediction_logging"}
-    defaults = {"default_energy_mode": "public_data", "enable_energy_caching": False}
+    defaults = {
+        "default_energy_mode": "public_data",
+        "enable_energy_caching": False,
+        "enable_time_prediction_logging": False,
+        "energy_redis_path": None,
+    }
 
     @classmethod
     def load_config(self, file_path=None):
@@ -34,6 +39,12 @@ def load_config(self, file_path=None):
         self.config_data = configparser.ConfigParser()
         self.config_data.read(file_path)
 
+        if self.section_name not in self.config_data:
+            self.config_data[self.section_name] = {}
+        for key, default_value in self.defaults.items():
+            if not self.config_data.has_option(self.section_name, key):
+                self.config_data.set(self.section_name, key, str(default_value))
+
         if self.get("enable_energy_caching") == True:
             if self.get("energy_redis_path") is None:
                 raise ConfigError(
@@ -42,6 +53,7 @@ def load_config(self, file_path=None):
             else:
                 r = redis.from_url(self.get("energy_redis_path"))
                 r.ping()
+        # print(self.config_data["default_energy_mode"])
 
     @classmethod
     def get(self, key):
@@ -60,4 +72,4 @@ def get(self, key):
                     value = value.lower() == "true"
             return value
         except (configparser.NoSectionError, configparser.NoOptionError):
-            return None
+            return self.defaults.get(key)  # Return default if key is missing

tests/test_loadshift_time.py

@@ -25,8 +25,9 @@ class TestOptimalTimeCore:
     def test_energy_data_blank(self):
         """test if no energy data is provided, the result defaults to the request time"""
         timestamp, message, average_percent_renewable = ts.predict_optimal_time(
-            None, 1, 1, 1, self.hard_finish_time_1, self.request_time_1
+            None, 1, 1, self.hard_finish_time_1, self.request_time_1
         )
+        # print(timestamp, message, average_percent_renewable)
         assert timestamp == int(self.request_time_1.timestamp())
         assert message == Message.NO_DATA
         assert average_percent_renewable == 0
@@ -37,9 +38,8 @@ def test_neg_hour(self):
             self.dummy_energy_data_1,
             -1,
             1,
-            1,
             self.hard_finish_time_1,
-            self.request_time_1,
+            self.request_time_1
         )
         assert timestamp == int(self.request_time_1.timestamp())
         assert message == Message.INVALID_DATA
@@ -51,9 +51,8 @@ def test_zero_hour(self):
             self.dummy_energy_data_1,
             0,
             1,
-            1,
             self.hard_finish_time_1,
-            self.request_time_1,
+            self.request_time_1
         )
         assert timestamp == int(self.request_time_1.timestamp())
         assert message == Message.INVALID_DATA
@@ -65,21 +64,26 @@ def test_neg_min(self):
             self.dummy_energy_data_1,
             1,
             -1,
-            1,
             self.hard_finish_time_1,
-            self.request_time_1,
+            self.request_time_1
         )
         assert timestamp == int(self.request_time_1.timestamp())
         assert message == Message.INVALID_DATA
         assert average_percent_renewable == 0
 
     def test_zero_per_renew(self):
         """test if 0 % renewable , the result defaults to the request time"""
+        dummy_energy_data_2 = pd.DataFrame(
+        {
+            "startTimeUTC": [1, 2, 3],
+            "totalRenewable": [1, 2, 3],
+            "percent_renewable": [0, 0, 0],
+        }
+        )
         timestamp, message, average_percent_renewable = ts.predict_optimal_time(
-            self.dummy_energy_data_1,
+            dummy_energy_data_2,
             1,
             0,
-            -10,
             self.hard_finish_time_1,
             self.request_time_1,
         )
@@ -89,13 +93,19 @@ def test_zero_per_renew(self):
 
     def test_neg_per_renew(self):
         """test if negative -ve % renew is provided, the result defaults to the request time"""
+        dummy_energy_data_3 = pd.DataFrame(
+            {
+                "startTimeUTC": [1, 2, 3],
+                "totalRenewable": [1, 2, 3],
+                "percent_renewable": [-1, -4, -5],
+            }
+        )
         timestamp, message, average_percent_renewable = ts.predict_optimal_time(
-            self.dummy_energy_data_1,
+            dummy_energy_data_3,
             1,
             0,
-            0,
             self.hard_finish_time_1,
-            self.request_time_1,
+            self.request_time_1
         )
         assert timestamp == int(self.request_time_1.timestamp())
         assert message == Message.NEGATIVE_PERCENT_RENEWABLE
@@ -107,9 +117,8 @@ def test_less_energy_data(self):
             self.dummy_energy_data_1,
             20,
             0,
-            10,
             self.hard_finish_time_1,
-            self.request_time_1,
+            self.request_time_1
         )
         assert timestamp == int(self.request_time_1.timestamp())
         assert message == Message.RUNTIME_LONGER_THAN_DEADLINE_ALLOWS
@@ -118,7 +127,7 @@ def test_if_incorrect_data_provided(self):
         """this is to test if  energy data provided does not contain the data for the request time"""
         data = pd.read_csv("tests/data/DE_forecast1.csv")
         timestamp, message, average_percent_renewable = ts.predict_optimal_time(
-            data, 20, 0, 10, self.hard_finish_time_2, self.request_time_2
+            data, 20, 0, self.hard_finish_time_2, self.request_time_2
         )
         assert timestamp == int(self.request_time_2.timestamp())
         assert message == Message.NO_DATA
@@ -225,7 +234,7 @@ def test_multiple(self):
     def test_data_validation_country(self):
         timestamp1 = int(datetime.now(timezone.utc).timestamp())
         timestamp, message, average_percent_renewable = ts.predict_now(
-            "UFO", 10, 0, datetime(2024, 9, 7), "percent_renewable", 30
+            "UFO", 10, 0, datetime(2024, 9, 7), "percent_renewable"
         )
         print(timestamp1, timestamp, message)
         assert timestamp - timestamp1 <= 10
@@ -269,7 +278,6 @@ def test_all_country():
             energy_data,
             row["runtime_hour"],
             row["runtime_min"],
-            row["percent_renewable"],
             end,
             start,
         )

tests/use_tools.py

@@ -0,0 +1,13 @@
+from codegreen_core.utilities.message import CodegreenDataError, Message
+from datetime import datetime, timezone, timedelta
+import codegreen_core.tools.loadshift_time as ts
+import pandas as pd
+import pytz
+
+try:
+  a,b,c, = ts.predict_now("DE",12,0,datetime(2024,10,30,23,00,00))
+except Exception as  e:
+  print(e)
+
+
+#print(a,b,c)