stlflib 1.0.1__tar.gz

stlflib-1.0.1/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.1
+Name: stlflib
+Version: 1.0.1
+Summary: Short-Term Forecasting of Regional Electrical Load Based on CatBoost Model
+Home-page: https://github.com/caapel/ForecastPowerEnergy
+Author: caapel
+Author-email: caapel@mail.ru
+License: KSPEU License
+Project-URL: GitHub, https://github.com/caapel/ForecastPowerEnergy
+Keywords: STLF
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ephem
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: tqdm
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: seaborn
+Requires-Dist: matplotlib
+Requires-Dist: catboost
+Requires-Dist: graphviz
+Requires-Dist: scikit-learn
+
+# Short-Term Load Forecasting Based on CatBoost Model Library (STLFLib)
+
+This is a Python STLF machine learning library designed for generating energy consumption bids for the DAM (day-ahead market). 
+The library is distributed under the KSPEU license ([RU 2025688100](https://new.fips.ru/registers-doc-view/fips_servlet?DB=EVM&DocNumber=2025688100&TypeFile=html)). For commercial use, please contact the author: caapel@mail.ru.
+
+----------
+
+## How to install ##
+To install, you can use the command:
+
+    pip install stlflib
+
+Or download the repository from [GitHub](https://github.com/caapel/ForecastPowerEnergy) (private access)
+
+----------
+
+## Using ##
+The essence of this project and its library is described in detail in the study [***Short-Term Forecasting of Regional Electrical Load Based on XGBoost Model***](https://doi.org/10.3390/en18195144)
+> In this file you will not find a detailed description and instructions on how to work with this library; 
+> only a description of each of the basic library modules.
+
+### Dependency ##
+The **dependency** module (located in the `dependency.py` file) contains a complete list of dependencies.
+The module has only one function:
+- *print_dependency()* - prints the versions of installed dependencies and the current version of STLFLib
+
+### ServiceDB ### 
+The **serviceDB** module (located in the `serviceDB.py` file) contains a set of tools for working with the database:
+<br>-------------------------------create---------------------------------<br>
+- *generate_volume_df(path)* - generate a dataframe with archived energy consumption data from prepared .xls-files located at `path`
+- *get_weather(date)* - generate a weather archive/forecast (outside air temperature) for the specified date with a sampling frequency of 1 hour
+- *get_br_feature(date)* - load a BEM (Balancing energy Market) archive/forecast for the specified date
+- *get_RSV_rate(date)* - load the unregulated DAM price for the specified date (per month)
+- *updating_or_create_df(get_function, filename, start=datetime(2013, 1, 1).date())* - create a new (from the specified date) or replenish an existing database (filename.xlsx) with missing data up to the end of the previous month, returning the resulting dataframe.
+- *merge_and_export_DB(total_volume_df, df_weather, df_br_feature, filename='DataBase.xlsx')* - merge dataframes total_volume_df (`Volume.xlsx`), df_weather (`Weather.xlsx`), and df_br_feature (`br_feature.xlsx`) by the 'Date' column into one common database (by default, `DataBase.xlsx`)
+<br>-------------------------------service--------------------------------<br>
+- *get_empty_daily_df(date)* - Creates an empty dataframe (25 rows: from 0:00 to 24:00) for the specified date (for full temperature interpolation)
+- *add_date_scalar(df)* - Adds additional categorical features to the dataframe: Day, Month, Year, WeekDay
+- *is_check_DataBase(df)* - Checks database integrity
+- *act_pred_reverse(df_br_feature)* - Replaces missing actual (Act) consumption and BR generation values ​​with planned (Pred) values. This function is used to generate a forecast for the current day, when the actual values ​​of `ActCons` and `ActGen` are not available for the entire day.
+- *get_files_from_path(path='_raw_Data_TatEnergosbyt')* - Retrieving operational data from the directory (by default, `/_raw_Data_TatEnergosbyt`)
+- *update_DataBase(total_oper_df, filename='DataBase.xlsx')* - Updating the database by adding operational data from `total_oper_df`
+
+### Preprocessing ###
+The **preprocessing** module (located in the `preprocessing.py` file) contains data preprocessing tools for subsequent transfer of this data to the **core** functions (CatBoostRegressor):
+- *get_type_day(df)* - encoding the day type (`TypeDay`) based on the `df.Date` column of the DataTime format. The encoding is performed based on the industrial calendar of the Republic of Tatarstan.
+- *get_light(df)* - encoding the light interval (`Light`) based on the `df.Date` column of the DataTime format. The encoding is performed based on the geographic location of the city of Kazan.
+- *get_season(df)* - encoding seasonality based on the `df.Date` column of the DataTime format.
+- *prepareData(df, lag_start=1, lag_end=7)* - data preprocessing function. Preprocessing includes: adding day type, light interval, seasonality, and energy consumption lag (default 1...7 days)
+
+### Core ###
+The **core** module (located in the `core.py` file) is the main class in the library. It is based on `CatBoostRegressor` and has a number of functions:
+- *predict_volume(df_general, df_predict, max_depth, learn_period)*
+- *get_df_predicted(df_general, max_depth, learn_period, model, date_start, date_end)* - generates a data frame with the predicted energy consumption volume for the specified planning horizon
+- *date_str_format(df_predicted)* - generates a date string for the exported xlsx file
+- *get_DAM_order(df_general, max_depth, learn_period, model, date_start, date_end)* - a function that generates a DAM order and exports it to xlsx format
+
+### Validating ###
+The **validating** helper module (located in the `validating.py` file) is designed to validate the **core** functions:
+- *get_df_val_predicted(df_general, df_general_date_index, max_depth, learn_period, model, date_start, date_end)* - function for generating a dataframe with predicted energy consumption volumes for the specified planning horizon, adapted for validation calculations (simulating the absence of 'ActCons' and 'ActGen' data after 7 AM, offline access to the weather forecast and BEM data)
+- *get_df_validate(df_general, df_general_date_index, max_depth, learn_period, model, date_start, date_end, logging=True)* - function for validating the model for the specified time interval. Returns a validation dataframe with predicted values.
+- *get_df_validate_with_loss(df_validate_result, df_RSV_vs_BR_rate)* - adds a 'loss' column with BEM losses to the resulting dataframe.
+- *diff_predict_vs_fact(df_validate_result)* - outputs validation results in table and graph form (Matplotlib object).
+- *Grid_Search(df_general, df_general_date_index, max_depth_grid, learn_period_grid, model, date_start, date_end)* - grid search for optimal training period and tree depth.
+- *search_result_highlighting(df_search_result)* - highlights the search results of the Grid_Search() function.
+
+### EDA ###
+The **EDA** graphics module (located in the `EDA.py` file) is designed to display the results of exploratory data analysis. In developing.
+- *draw_learning_curve(df_general, max_depth, model, fontsize=15)* - calculates and plots the learning curve.

stlflib-1.0.1/README.md

@@ -0,0 +1,69 @@
+# Short-Term Load Forecasting Based on CatBoost Model Library (STLFLib)
+
+This is a Python STLF machine learning library designed for generating energy consumption bids for the DAM (day-ahead market). 
+The library is distributed under the KSPEU license ([RU 2025688100](https://new.fips.ru/registers-doc-view/fips_servlet?DB=EVM&DocNumber=2025688100&TypeFile=html)). For commercial use, please contact the author: caapel@mail.ru.
+
+----------
+
+## How to install ##
+To install, you can use the command:
+
+    pip install stlflib
+
+Or download the repository from [GitHub](https://github.com/caapel/ForecastPowerEnergy) (private access)
+
+----------
+
+## Using ##
+The essence of this project and its library is described in detail in the study [***Short-Term Forecasting of Regional Electrical Load Based on XGBoost Model***](https://doi.org/10.3390/en18195144)
+> In this file you will not find a detailed description and instructions on how to work with this library; 
+> only a description of each of the basic library modules.
+
+### Dependency ##
+The **dependency** module (located in the `dependency.py` file) contains a complete list of dependencies.
+The module has only one function:
+- *print_dependency()* - prints the versions of installed dependencies and the current version of STLFLib
+
+### ServiceDB ### 
+The **serviceDB** module (located in the `serviceDB.py` file) contains a set of tools for working with the database:
+<br>-------------------------------create---------------------------------<br>
+- *generate_volume_df(path)* - generate a dataframe with archived energy consumption data from prepared .xls-files located at `path`
+- *get_weather(date)* - generate a weather archive/forecast (outside air temperature) for the specified date with a sampling frequency of 1 hour
+- *get_br_feature(date)* - load a BEM (Balancing energy Market) archive/forecast for the specified date
+- *get_RSV_rate(date)* - load the unregulated DAM price for the specified date (per month)
+- *updating_or_create_df(get_function, filename, start=datetime(2013, 1, 1).date())* - create a new (from the specified date) or replenish an existing database (filename.xlsx) with missing data up to the end of the previous month, returning the resulting dataframe.
+- *merge_and_export_DB(total_volume_df, df_weather, df_br_feature, filename='DataBase.xlsx')* - merge dataframes total_volume_df (`Volume.xlsx`), df_weather (`Weather.xlsx`), and df_br_feature (`br_feature.xlsx`) by the 'Date' column into one common database (by default, `DataBase.xlsx`)
+<br>-------------------------------service--------------------------------<br>
+- *get_empty_daily_df(date)* - Creates an empty dataframe (25 rows: from 0:00 to 24:00) for the specified date (for full temperature interpolation)
+- *add_date_scalar(df)* - Adds additional categorical features to the dataframe: Day, Month, Year, WeekDay
+- *is_check_DataBase(df)* - Checks database integrity
+- *act_pred_reverse(df_br_feature)* - Replaces missing actual (Act) consumption and BR generation values ​​with planned (Pred) values. This function is used to generate a forecast for the current day, when the actual values ​​of `ActCons` and `ActGen` are not available for the entire day.
+- *get_files_from_path(path='_raw_Data_TatEnergosbyt')* - Retrieving operational data from the directory (by default, `/_raw_Data_TatEnergosbyt`)
+- *update_DataBase(total_oper_df, filename='DataBase.xlsx')* - Updating the database by adding operational data from `total_oper_df`
+
+### Preprocessing ###
+The **preprocessing** module (located in the `preprocessing.py` file) contains data preprocessing tools for subsequent transfer of this data to the **core** functions (CatBoostRegressor):
+- *get_type_day(df)* - encoding the day type (`TypeDay`) based on the `df.Date` column of the DataTime format. The encoding is performed based on the industrial calendar of the Republic of Tatarstan.
+- *get_light(df)* - encoding the light interval (`Light`) based on the `df.Date` column of the DataTime format. The encoding is performed based on the geographic location of the city of Kazan.
+- *get_season(df)* - encoding seasonality based on the `df.Date` column of the DataTime format.
+- *prepareData(df, lag_start=1, lag_end=7)* - data preprocessing function. Preprocessing includes: adding day type, light interval, seasonality, and energy consumption lag (default 1...7 days)
+
+### Core ###
+The **core** module (located in the `core.py` file) is the main class in the library. It is based on `CatBoostRegressor` and has a number of functions:
+- *predict_volume(df_general, df_predict, max_depth, learn_period)*
+- *get_df_predicted(df_general, max_depth, learn_period, model, date_start, date_end)* - generates a data frame with the predicted energy consumption volume for the specified planning horizon
+- *date_str_format(df_predicted)* - generates a date string for the exported xlsx file
+- *get_DAM_order(df_general, max_depth, learn_period, model, date_start, date_end)* - a function that generates a DAM order and exports it to xlsx format
+
+### Validating ###
+The **validating** helper module (located in the `validating.py` file) is designed to validate the **core** functions:
+- *get_df_val_predicted(df_general, df_general_date_index, max_depth, learn_period, model, date_start, date_end)* - function for generating a dataframe with predicted energy consumption volumes for the specified planning horizon, adapted for validation calculations (simulating the absence of 'ActCons' and 'ActGen' data after 7 AM, offline access to the weather forecast and BEM data)
+- *get_df_validate(df_general, df_general_date_index, max_depth, learn_period, model, date_start, date_end, logging=True)* - function for validating the model for the specified time interval. Returns a validation dataframe with predicted values.
+- *get_df_validate_with_loss(df_validate_result, df_RSV_vs_BR_rate)* - adds a 'loss' column with BEM losses to the resulting dataframe.
+- *diff_predict_vs_fact(df_validate_result)* - outputs validation results in table and graph form (Matplotlib object).
+- *Grid_Search(df_general, df_general_date_index, max_depth_grid, learn_period_grid, model, date_start, date_end)* - grid search for optimal training period and tree depth.
+- *search_result_highlighting(df_search_result)* - highlights the search results of the Grid_Search() function.
+
+### EDA ###
+The **EDA** graphics module (located in the `EDA.py` file) is designed to display the results of exploratory data analysis. In developing.
+- *draw_learning_curve(df_general, max_depth, model, fontsize=15)* - calculates and plots the learning curve.

stlflib-1.0.1/STLFLib/EDA.py

@@ -0,0 +1,83 @@
+from .dependency import *
+from .validating import *
+
+def draw_learning_curve(df_general, max_depth, model, fontsize=15):
+    
+    '''
+    SYNOPSYS: Расчёт и построение кривой обучения
+
+    KEYWORD ARGUMENTS:
+    df_general -- валидируемая генеральная совокупность
+    max_depth -- максимальная глубина решающего дерева регрессора
+    model -- тип модели
+    fontsize -- размер шрифта на графике
+
+    RETURNS:
+    None
+    
+    EXAMPLE:
+    >>> draw_learning_curve(df_general, max_depth=6, model=model)
+    '''
+    
+    def X_y_split(df_general, learn_period):
+    
+        '''
+        SYNOPSYS: Разделение выборки на целевой и исходные признаки
+        '''
+        
+        datetime=df_general.Date.iloc[-1]
+        
+        df_train = df_general[(df_general.Date > datetime - timedelta(days=round(365.25*learn_period), hours=0)) &
+                              (df_general.Date <= datetime)]
+        
+        return df_train.drop(columns=['Date', 'Volume']), df_train.Volume
+    
+    if model == 'br3_act':  # c 30 ноября 2025 перейти на 8 лет для br3 и 13 лет для br2
+        df_general = df_general.drop(columns=['PredCons', 'PredGen'])
+        learn_period = 7
+    elif model == 'br2_act':
+        df_general = df_general.drop(columns=['PredCons', 'PredGen', 'Price'])
+        learn_period = 12
+    
+    X, y = X_y_split(df_general, learn_period)
+
+    engine = catboost.CatBoostRegressor(silent=True,
+                                       n_estimators = 200,
+                                       max_depth = max_depth)
+    common_params = {
+                     "X": X,
+                     "y": y,
+                     "train_sizes": np.linspace(1/learn_period, 1.0, learn_period),
+                     "cv": TimeSeriesSplit(n_splits=5),
+                     "scoring": 'neg_mean_absolute_percentage_error',
+                     "n_jobs": -1,
+                     "line_kw": {"marker": "o"},
+                     "std_display_style": "fill_between",
+                     "score_name": "neg MAPE",
+                    }
+
+    plt.figure(figsize=(10, 5))
+    plt.rcParams['axes.prop_cycle'] = plt.cycler(color=['#1f77b4', '#8ec489']) 
+    plt.rcParams['font.family'] = 'Palatino Linotype'
+    plt.rcParams['font.size'] = fontsize    
+    
+    LCD = LearningCurveDisplay.from_estimator(engine, **common_params)
+    train_sizes = LCD.train_sizes
+    test_scores = LCD.test_scores
+    mean_test_scores = [test_scores[i].mean() for i in range(len(test_scores))]    
+    opt_y = max(mean_test_scores)
+    opt_x = train_sizes[mean_test_scores.index(opt_y)]
+    
+    for i in range(len(mean_test_scores)):
+        plt.text(train_sizes[i], mean_test_scores[i], f'{i+1}', ha='center', va='bottom')
+    
+    plt.annotate('Optimal period', xy=(opt_x, opt_y), 
+                 xycoords='data', xytext=(opt_x-4000, opt_y-0.015), 
+                 textcoords='data', fontsize=fontsize, 
+                 arrowprops=dict(arrowstyle='-|>'))
+    
+    plt.title(f'Learning Curve for {model} (max_depth={max_depth})', fontsize=fontsize)
+    plt.legend(['Training score', 'Test score'], loc='lower right')
+    plt.tight_layout()
+    #plt.savefig(f'pictures/br2_Learning_Curve(max_depth={max_depth}).png', dpi = 300, transparent = True)
+    plt.show()

stlflib-1.0.1/STLFLib/__init__.py

@@ -0,0 +1,14 @@
+'''
+
+Short-Term Forecasting of Regional Electrical Load Based on CatBoost Model library  (STLFLib) v. 1.0.0.0
+
+The KSPEU License Copyrigth © 2025 caapel
+
+'''
+
+from .dependency import *
+from .serviceDB import *
+from .preprocessing import *
+from .core import *
+from .validating import *
+from .EDA import *

stlflib-1.0.1/STLFLib/core.py

@@ -0,0 +1,242 @@
+from .dependency import *
+from .preprocessing import *
+from .serviceDB import *
+
+def predict_volume(df_general, df_predict, max_depth, learn_period):
+
+    '''
+    SYNOPSYS: Функция обучения модели и прогнозирования объемов энергопотребления
+
+    KEYWORD ARGUMENTS:
+    df_general -- датафрейм с генеральной совокупностью данных (X_train, y_train)
+    df_predict -- суточный датафрейм с исходными данными для прогноза (x_pred)
+    max_depth -- максимальная глубина решающего дерева регрессора
+    learn_period -- период обучения модели (размер тренировочной выборки)
+
+    RETURNS:
+    df_predict : pandas.core.frame.DataFrame
+    
+    EXAMPLES:
+    >>> predict_volume(df_general, df_predict, datetime(2025, 8, 30, 1), max_depth, learn_period).info()
+    
+    <class 'pandas.core.frame.DataFrame'>
+    RangeIndex: 24 entries, 0 to 23
+    Data columns (total 21 columns):
+    #   Column       Non-Null Count  Dtype         
+    ---  ------       --------------  -----         
+    0   Date         24 non-null     datetime64[ns]
+    1   Year         24 non-null     int64         
+    2   Month        24 non-null     int64         
+    3   Day          24 non-null     int64         
+    4   Hour         24 non-null     int64         
+    5   Weekday      24 non-null     int64         
+    6   Volume       24 non-null     float64       
+    7   Temperature  24 non-null     float64       
+    8   ActCons      24 non-null     int64         
+    9   ActGen       24 non-null     int64         
+    10  Price        24 non-null     int64         
+    11  TypeDay      24 non-null     int64         
+    12  Light        24 non-null     int64         
+    13  Season       24 non-null     int64         
+    14  lag-1        24 non-null     float64       
+    15  lag-2        24 non-null     float64       
+    16  lag-3        24 non-null     float64       
+    17  lag-4        24 non-null     float64       
+    18  lag-5        24 non-null     float64       
+    19  lag-6        24 non-null     float64       
+    20  lag-7        24 non-null     float64       
+    dtypes: datetime64[ns](1), float64(9), int64(11)
+    memory usage: 4.1 KB
+    '''
+    
+    # формируем оптимальную обучающую выборку
+    df_train = df_general[df_general.Date > df_predict.iloc[0].Date - timedelta(days=365*learn_period+1, hours=1)]
+
+    # обучаем модель
+    model = catboost.CatBoostRegressor(silent=True,
+                                       n_estimators = 200,
+                                       max_depth = max_depth)
+
+    model.fit(df_train.drop(columns=['Date', 'Volume']), df_train.Volume)
+
+    # прогнозируем объёмы потребления на ближайшие сутки
+    df_predict.Volume = model.predict(df_predict.drop(columns=['Date', 'Volume']))
+   
+    return df_predict
+
+
+def get_df_predicted(df_general,
+                     max_depth, 
+                     learn_period,
+                     model,
+                     date_start = datetime.now().date(), 
+                     date_end = datetime.now().date() + timedelta(days=1),
+                     ):
+    
+    '''
+    SYNOPSYS: Функция генерации датафрейма с прогнозными объёмами энергопотребления под указанный горизонт планирования
+
+    KEYWORD ARGUMENTS:
+    df_general -- актуальная генеральная совокупность ко дню прогноза
+    max_depth -- максимальная глубина решающего дерева регрессора
+    learn_period -- период обучения модели (размер тренировочной выборки)
+    model -- тип модели (по умолчанию br3_act: [ActCons, ActGen, Price])
+    date_start -- дата от начала старта прогноза (по умолчанию – текущий день)
+    date_end -- дата окончания прогноза (по умолчанию – сутки вперёд)
+
+    RETURNS:
+    df_predict : pandas.core.frame.DataFrame
+    
+    EXAMPLE:
+    # генерация прогнозных объемов потребления ЭЭ на сутки вперед
+    >>> get_df_predicted(df_general, max_depth, learn_period, model)
+
+    # генерация прогнозных объемов потребления ЭЭ от указанной даты на сутки вперед
+    >>> get_df_predicted(df_general, max_depth, learn_period, model, date_start=datetime(2024, 5, 12).date())
+
+    # генерация прогнозных объемов потребления ЭЭ от текущего дня до указанной даты
+    >>> get_df_predicted(df_general, max_depth, learn_period, model, date_end=datetime(2024, 6, 15).date())
+
+    # генерация прогнозных объемов потребления ЭЭ от одной до другой указанной даты
+    >>> get_df_predicted(df_general, max_depth, learn_period, model, date_start=datetime(2024, 5, 14).date(), 
+                                                        date_end=datetime(2024, 5, 16).date())
+
+    # генерация прогнозных объемов потребления ЭЭ на двое суток вперед
+    >>> get_df_predicted(df_general, max_depth, learn_period, model, date_end=datetime.now().date() + timedelta(days=2))
+    '''
+    
+    # генерируем пустой датафрейм под итоговый результат
+    df_predicted = pd.DataFrame()
+    
+    #for date in trange((date_end - date_start).days + 1, desc=f"days progress"):  # виджет процесса расчёта по суткам
+    for date in range((date_end - date_start).days + 1):
+    
+        # генерируем пустой суточный датафрейм с погодными и календарными признаками
+        df_predicted_daily = add_date_scalar(get_weather(date_start + timedelta(days=date)))
+        
+        # разделяем логику обучения (текущие сутки с учётом БР, последующие - без учёта БР)
+        if date == 0:
+            
+            if model == 'br3_act':
+                # удаляем столбцы с прогнозными значениями генерации и потребления БР СО ЕЭС
+                df_general = df_general.drop(columns=['PredCons', 'PredGen'])
+                 # выгружаем данные (прогнозные и часть актуальных) с балансирующего рынка на текущие сутки
+                df_predicted_daily = df_predicted_daily.merge(get_br_feature(date_start), on='Date')
+            elif model == 'br2_act':
+                # удаляем столбцы с прогнозными значениями генерации и потребления БР СО ЕЭС и 1 признак: `Price`
+                df_general = df_general.drop(columns=['PredCons', 'PredGen', 'Price'])
+                 # выгружаем данные (прогнозные и часть актуальных) с балансирующего рынка на текущие сутки
+                df_predicted_daily = df_predicted_daily.merge(get_br_feature(date_start).drop(columns='Price'), on='Date')
+            
+            # восстанавливаем пропуски ActCons и ActGen данными из столбцов PredCons и PredGen
+            df_predicted_daily = act_pred_reverse(df_predicted_daily)
+            
+        elif date == 1:
+
+            if model == 'br3_act':
+                df_general = df_general.drop(columns=['ActCons', 'ActGen', 'Price'])
+            elif model == 'br2_act':
+                df_general = df_general.drop(columns=['ActCons', 'ActGen'])
+
+        # добавляем последние 168 (24 · 7) строк от df_general для генерации временного лага
+        df_predicted_daily = pd.concat([df_general.tail(168), df_predicted_daily])
+
+        # генерируем временной лаг (1 полная неделя)
+        df_predicted_daily = prepareData(df_predicted_daily)
+
+        # получаем прогнозные значения на текущие сутки
+        df_predicted_daily = predict_volume(df_general, 
+                                            df_predicted_daily, 
+                                            max_depth, 
+                                            learn_period)
+
+        # добавляем полученные прогнозные значения в итоговый прогнозный фрейм
+        df_predicted = pd.concat([df_predicted, df_predicted_daily])
+
+        # пополняем генеральную совокупность текущими сутками (+24 строки) для планирования следующего дня
+        df_general = pd.concat([df_general, df_predicted_daily])
+
+    df_predicted.rename(columns = {'Volume':'Predicted'}, inplace = True)
+
+    # убрать .tail(24) если необходимо получить прогноз на несколько дней
+    return df_predicted[['Date', 'Predicted']].tail(24*(date_end - date_start).days)
+
+
+def date_str_format(df_predicted):
+    
+    '''
+    SYNOPSYS: генерация строки с датой для экспортируемого xlsx-файла
+
+    KEYWORD ARGUMENTS:
+    date -- дата, на которую генерируется прогноз
+
+    RETURNS: str
+    
+    EXAMPLE:
+    >>> date_str_format(df_predicted)
+    '12.11.2025'
+
+    >>> date_str_format(df_predicted)
+    '12-13.11.2025'
+
+    >>> date_str_format(df_predicted)
+    '30.11.2025-01.12.2025'
+    '''
+    
+    def single_date_str_format(date):    
+        return f'{0 if date.day < 10 else ""}{date.day}.{0 if date.month < 10 else ""}{date.month}.{date.year}'
+    
+    date_start = df_predicted.iloc[1].Date.date()
+    date_end = df_predicted.iloc[-2].Date.date()
+    
+    if df_predicted.shape[0] == 24:
+        return single_date_str_format(date_start)
+    else:
+        if date_start.month != date_end.month: # даты начала и конца выходят за пределы текущего месяца
+            return f'{single_date_str_format(date_start)}-{single_date_str_format(date_end)}'
+        else: # даты начала и конца не выходят за пределы текущего месяца
+            str_day = f'{0 if date_start.day < 10 else ""}{date_start.day}-{0 if date_end.day < 10 else ""}{date_end.day}'
+            str_month = f'{0 if date_start.month < 10 else ""}{date_start.month}'
+            return f'{str_day}.{str_month}.{date_start.year}'
+          
+
+def get_DAM_order(df_general, 
+                  max_depth, 
+                  learn_period, 
+                  model = 'br3_act',
+                  date_start = datetime.now().date(), 
+                  date_end = datetime.now().date() + timedelta(days=1),
+                  ):
+    
+    '''
+    SYNOPSYS: функция, генерирующая заявку на РСВ с экспортом в xlsx-форму
+
+    KEYWORD ARGUMENTS:
+    df_general -- актуальная генеральная совокупность ко дню прогноза
+    max_depth -- максимальная глубина решающего дерева регрессора
+    learn_period -- период обучения модели (размер тренировочной выборки)
+    model -- тип модели (по умолчанию br3_act: [ActCons, ActGen, Price])
+    date_start -- дата от начала старта прогноза (по умолчанию – текущий день)
+    date_end -- дата окончания прогноза (по умолчанию – сутки вперёд)
+
+    RETURNS: *.xlsx
+    
+    EXAMPLE:
+    >>> get_DAM_order(df_general, max_depth, learn_period)
+
+    >>> get_DAM_order(
+                      df_general, max_depth, learn_period, model,
+                      date_start=datetime.now().date(), date_end=datetime.now().date() + timedelta(days=2))
+                     )
+    '''    
+    
+    df_predicted = get_df_predicted(df_general, max_depth, learn_period, model, date_start, date_end)
+    return_days = (date_end - date_start).days
+    
+    if df_predicted.shape[0] == 24*return_days:
+        df_predicted.to_excel(f'Predicted({date_str_format(df_predicted)}).xlsx', index=False)
+        print(f'Результаты прогноза сохранены в файле Predicted({date_str_format(df_predicted)}).xlsx')
+    else:
+        print("\033[1;31m{}".format('WARNING: No data in exported dataframe'))
+
+    return df_predicted

stlflib-1.0.1/STLFLib/dependency.py

@@ -0,0 +1,46 @@
+"""
+import all dependencies
+"""
+
+import os
+import re
+import ephem
+import locale
+import requests
+import warnings
+import calendar
+from bs4 import BeautifulSoup
+from tqdm.notebook import trange
+
+import notebook
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import matplotlib
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+from platform import python_version
+import catboost
+import graphviz
+from datetime import time
+from datetime import datetime
+from datetime import timedelta
+import sklearn
+from sklearn.metrics import mean_absolute_error as MAE
+from sklearn.metrics import mean_absolute_percentage_error as MAPE
+from sklearn.model_selection import ShuffleSplit
+from sklearn.model_selection import GridSearchCV
+from sklearn.model_selection import TimeSeriesSplit
+from sklearn.model_selection import LearningCurveDisplay
+
+def print_dependency():
+    print(f"python: v {python_version()}")
+    print(f"Jupyter Notebook: v {notebook.__version__}")
+    print(f"numpy: v {np.__version__}")
+    print(f"pandas: v {pd.__version__}")
+    print(f"seaborn: v {sns.__version__}")
+    print(f"graphviz: v {graphviz.__version__}")
+    print(f"matplotlib: v {matplotlib.__version__}")
+    print(f"sklearn: v {sklearn.__version__}")
+    print(f"CatBoost: v {catboost.__version__}")
+    print(f"STLFLib: v 1.0.0")