emhass 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

emhass/forecast.py

@@ -186,7 +186,7 @@ class Forecast(object):
         self.logger.info("Retrieving weather forecast data using method = "+method)
         self.weather_forecast_method = method # Saving this attribute for later use to identify csv method usage
         if method == 'scrapper':
-            freq_scrap = pd.to_timedelta(60, "minutes") # The scrapping time step is 60min
+            freq_scrap = pd.to_timedelta(60, "minutes") # The scrapping time step is 60min on clearoutside
             forecast_dates_scrap = pd.date_range(start=self.start_forecast,
                                                  end=self.end_forecast-freq_scrap, 
                                                  freq=freq_scrap).round(freq_scrap, ambiguous='infer', nonexistent='shift_forward')
@@ -204,7 +204,7 @@ class Forecast(object):
             col_names = [list_names[i].get_text() for i in selected_cols]
             list_tables = [list_tables[i] for i in selected_cols]
             # Building the raw DF container
-            raw_data = pd.DataFrame(index=range(24), columns=col_names, dtype=float)
+            raw_data = pd.DataFrame(index=range(len(forecast_dates_scrap)), columns=col_names, dtype=float)
             for count_col, col in enumerate(col_names):
                 list_rows = list_tables[count_col].find_all('li')
                 for count_row, row in enumerate(list_rows):
@@ -235,7 +235,8 @@ class Forecast(object):
                 "Authorization": "Bearer " + self.retrieve_hass_conf['solcast_api_key'],
                 "content-type": "application/json",
                 }
-            url = "https://api.solcast.com.au/rooftop_sites/"+self.retrieve_hass_conf['solcast_rooftop_id']+"/forecasts?hours=24"
+            days_solcast = int(len(self.forecast_dates)*self.freq.seconds/3600)
+            url = "https://api.solcast.com.au/rooftop_sites/"+self.retrieve_hass_conf['solcast_rooftop_id']+"/forecasts?hours="+str(days_solcast)
             response = get(url, headers=headers)
             '''import bz2 # Uncomment to save a serialized data for tests
             import _pickle as cPickle
@@ -263,7 +264,11 @@ class Forecast(object):
                 self.retrieve_hass_conf['solar_forecast_kwp'] = 5
             if  self.retrieve_hass_conf['solar_forecast_kwp'] == 0:
                 self.logger.warning("The solar_forecast_kwp parameter is set to zero, setting to default 5")
-                self.retrieve_hass_conf['solar_forecast_kwp'] = 5                   
+                self.retrieve_hass_conf['solar_forecast_kwp'] = 5
+            if self.optim_conf['delta_forecast'].days > 1:
+                self.logger.warning("The free public tier for solar.forecast only provides one day forecasts")
+                self.logger.warning("Continuing with just the first day of data, the other days are filled with 0.0.")
+                self.logger.warning("Use the other available methods for delta_forecast > 1")
             headers = {
                 "Accept": "application/json"
                 }
@@ -289,7 +294,8 @@ class Forecast(object):
                 mask_down_data_df = data_tmp.copy(deep=True).fillna(method = "bfill").isnull()
                 data_tmp.loc[data_tmp.index[mask_up_data_df['yhat']==True],:] = 0.0
                 data_tmp.loc[data_tmp.index[mask_down_data_df['yhat']==True],:] = 0.0
-                data_tmp.interpolate(inplace=True)
+                data_tmp.interpolate(inplace=True, limit=1)
+                data_tmp = data_tmp.fillna(0.0)
                 if len(data) == 0:
                     data = copy.deepcopy(data_tmp)
                 else:
@@ -417,9 +423,9 @@ class Forecast(object):
                 # Setting the main parameters of the PV plant
                 location = Location(latitude=self.lat, longitude=self.lon)
                 temp_params = TEMPERATURE_MODEL_PARAMETERS['sapm']['close_mount_glass_glass']
-                cec_modules = bz2.BZ2File(self.emhass_conf['root_path'] / 'src/emhass/data/cec_modules.pbz2', "rb")
+                cec_modules = bz2.BZ2File(self.emhass_conf['root_path'] / 'data/cec_modules.pbz2', "rb")
                 cec_modules = cPickle.load(cec_modules)
-                cec_inverters = bz2.BZ2File(self.emhass_conf['root_path'] / 'src/emhass/data/cec_inverters.pbz2', "rb")
+                cec_inverters = bz2.BZ2File(self.emhass_conf['root_path'] / 'data/cec_inverters.pbz2', "rb")
                 cec_inverters = cPickle.load(cec_inverters)
                 if type(self.plant_conf['module_model']) == list:
                     P_PV_forecast = pd.Series(0, index=df_weather.index)
@@ -639,10 +645,10 @@ class Forecast(object):
                 days_list = get_days_list(days_min_load_forecast) 
                 if not rh.get_data(days_list, var_list):
                     return False
-            if  not rh.prepare_data(self.retrieve_hass_conf['var_load'], load_negative = self.retrieve_hass_conf['load_negative'],
-                            set_zero_min = self.retrieve_hass_conf['set_zero_min'], 
-                            var_replace_zero = var_replace_zero, 
-                            var_interp = var_interp):
+            if  not rh.prepare_data(
+                self.retrieve_hass_conf['var_load'], load_negative = self.retrieve_hass_conf['load_negative'],
+                set_zero_min = self.retrieve_hass_conf['set_zero_min'], 
+                var_replace_zero = var_replace_zero, var_interp = var_interp):
                 return False
             df = rh.df_final.copy()[[self.var_load_new]]
         if method == 'naive': # using a naive approach
@@ -747,7 +753,6 @@ class Forecast(object):
 
         """
         csv_path  = self.emhass_conf['data_path'] / csv_path
-
         if method == 'hp_hc_periods':
             df_final[self.var_load_cost] = self.optim_conf['load_cost_hc']
             list_df_hp = []
@@ -780,12 +785,11 @@ class Forecast(object):
         else:
             self.logger.error("Passed method is not valid")
             return False
-            
         return df_final
     
     def get_prod_price_forecast(self, df_final: pd.DataFrame, method: Optional[str] = 'constant',
-                               csv_path: Optional[str] = "data_prod_price_forecast.csv", 
-                               list_and_perfect: Optional[bool] = False) -> pd.DataFrame:
+                                csv_path: Optional[str] = "data_prod_price_forecast.csv", 
+                                list_and_perfect: Optional[bool] = False) -> pd.DataFrame:
 
         r"""
         Get the unit power production price for the energy injected to the grid.\
@@ -807,16 +811,13 @@ class Forecast(object):
         :rtype: pd.DataFrame
 
         """
-
         csv_path  = self.emhass_conf['data_path'] / csv_path
-
         if method == 'constant':
             df_final[self.var_prod_price] = self.optim_conf['prod_sell_price']
         elif method == 'csv':
             forecast_dates_csv = self.get_forecast_days_csv(timedelta_days=0)
-            forecast_out = self.get_forecast_out_from_csv_or_list(df_final,
-                                                          forecast_dates_csv,
-                                                          csv_path)
+            forecast_out = self.get_forecast_out_from_csv_or_list(
+                df_final, forecast_dates_csv, csv_path)
             df_final[self.var_prod_price] = forecast_out
         elif method == 'list': # reading a list of values
             # Loading data from passed list
@@ -837,6 +838,5 @@ class Forecast(object):
         else:
             self.logger.error("Passed method is not valid")
             return False
-            
         return df_final
     

emhass/machine_learning_regressor.py

@@ -76,16 +76,8 @@ class MLRegressor:
 
     """
 
-    def __init__(  # noqa: PLR0913
-        self: MLRegressor,
-        data: pd.DataFrame,
-        model_type: str,
-        regression_model: str,
-        features: list,
-        target: str,
-        timestamp: str,
-        logger: logging.Logger,
-    ) -> None:
+    def __init__(self: MLRegressor, data: pd.DataFrame, model_type: str, regression_model: str,
+                 features: list, target: str, timestamp: str, logger: logging.Logger) -> None:
         r"""Define constructor for the forecast class.
 
         :param data: The data that will be used for train/test
@@ -124,11 +116,7 @@ class MLRegressor:
         self.grid_search = None
 
     @staticmethod
-    def add_date_features(
-        data: pd.DataFrame,
-        date_features: list,
-        timestamp: str,
-    ) -> pd.DataFrame:
+    def add_date_features(data: pd.DataFrame, date_features: list, timestamp: str) -> pd.DataFrame:
         """Add date features from the input DataFrame timestamp.
 
         :param data: The input DataFrame
@@ -152,23 +140,18 @@ class MLRegressor:
             df["day"] = [i.day for i in df["timestamp"]]
         if "hour" in date_features:
             df["hour"] = [i.day for i in df["timestamp"]]
-
         return df
 
     def get_regression_model(self: MLRegressor) -> tuple[str, str]:
-        """Get the base model and parameter grid for the specified regression model.
-
+        r"""
+        Get the base model and parameter grid for the specified regression model.
         Returns a tuple containing the base model and parameter grid corresponding to \
             the specified regression model.
 
-        Args:
-        ----
-            self: The instance of the MLRegressor class.
-
-        Returns:
-        -------
-            A tuple containing the base model and parameter grid.
-
+        :param self: The instance of the MLRegressor class.
+        :type self: MLRegressor
+        :return: A tuple containing the base model and parameter grid.
+        :rtype: tuple[str, str]
         """
         if self.regression_model == "LinearRegression":
             base_model = REGRESSION_METHODS["LinearRegression"]["model"]
@@ -197,7 +180,7 @@ class MLRegressor:
         return base_model, param_grid
 
     def fit(self: MLRegressor, date_features: list | None = None) -> None:
-        """Fit the model using the provided data.
+        r"""Fit the model using the provided data.
 
         :param date_features: A list of 'date_features' to take into account when \
             fitting the model.
@@ -226,45 +209,24 @@ class MLRegressor:
                     "If no timestamp provided, you can't use date_features, going \
                     further without date_features.",
                 )
-
         y = self.data_exo[self.target]
         self.data_exo = self.data_exo.drop(self.target, axis=1)
         if self.timestamp is not None:
             self.data_exo = self.data_exo.drop(self.timestamp, axis=1)
-        X = self.data_exo  # noqa: N806
-
-        X_train, X_test, y_train, y_test = train_test_split(  # noqa: N806
-            X,
-            y,
-            test_size=0.2,
-            random_state=42,
-        )
-
+        X = self.data_exo 
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
         self.steps = len(X_test)
-
         base_model, param_grid = self.get_regression_model()
-
         self.model = make_pipeline(StandardScaler(), base_model)
-
         # Create a grid search object
-        self.grid_search = GridSearchCV(
-            self.model,
-            param_grid,
-            cv=5,
-            scoring="neg_mean_squared_error",
-            refit=True,
-            verbose=0,
-            n_jobs=-1,
-        )
-
+        self.grid_search = GridSearchCV(self.model, param_grid, cv=5, scoring="neg_mean_squared_error",
+                                        refit=True, verbose=0, n_jobs=-1)
         # Fit the grid search object to the data
         self.logger.info("Training a %s model", self.regression_model)
         start_time = time.time()
         self.grid_search.fit(X_train.values, y_train.values)
         self.logger.info("Elapsed time for model fit: %s", time.time() - start_time)
-
         self.model = self.grid_search.best_estimator_
-
         # Make predictions
         predictions = self.model.predict(X_test.values)
         predictions = pd.Series(predictions, index=X_test.index)
@@ -286,5 +248,4 @@ class MLRegressor:
         """
         self.logger.info("Performing a prediction for %s", self.model_type)
         new_values = np.array([new_values])
-
         return self.model.predict(new_values)