energy-reports-pkg 0.6.14__py3-none-any.whl

mindsett_energy_reports_pkg/mdl/utils_/cache_df_to_db/__init__.py

@@ -0,0 +1,11 @@
+
+from .append_df_to_table import append_df_to_table
+from mdl.utils_ import empty_table
+
+def cache_df_to_db(engine, table_name, df):
+
+    empty_table(engine, table_name, with_log=False)
+    append_df_to_table(engine, table_name, df)
+
+    return
+

mindsett_energy_reports_pkg/mdl/utils_/cache_df_to_db/append_df_to_table/__init__.py

@@ -0,0 +1,29 @@
+def append_df_to_table(engine, table_name, df):
+    
+    table_schema_name_list = table_name.split(".")
+
+    if len(table_schema_name_list) > 1:
+        table_schema = table_schema_name_list[0]
+        table_non_schema_name = table_schema_name_list[1]
+    else:
+        table_schema = "public"
+        table_non_schema_name = table_name
+        
+    total_records = len(df)
+    
+  
+    with engine.connect() as conn:
+  
+        df.to_sql(
+           name=table_non_schema_name,
+           con=conn,
+           if_exists="append",
+           schema=table_schema,
+           chunksize=5000,
+           index=False
+           )
+
+    print(f'The config cache in database table [{table_name}] is updated with [{total_records}] records.')
+    # print(f'[{total_records}] records have been written to Table [{table_name}] successfully.')
+   
+    return 

mindsett_energy_reports_pkg/mdl/utils_/cache_df_to_db/empty_table/__init__.py

@@ -0,0 +1,11 @@
+def empty_table(engine, table_name, with_log=True):
+    
+    with engine.connect() as conn:
+
+        # delete data (empty) in the table
+        query_empty_table = f"""DELETE FROM {table_name};"""
+        conn.execute(query_empty_table) 
+
+    if with_log:
+        print(f'The table [{table_name}] is empty now.')
+    return

mindsett_energy_reports_pkg/mdl/utils_/cache_obj/__init__.py

@@ -0,0 +1,50 @@
+import os
+import pickle
+import inspect
+import re
+import traceback
+# from varname import nameof
+
+def cache_obj(varible, var_name=None, cache_dir='./_cache_', max_count=10000, mode='w', pkg_name=None, print_on=True):
+
+    if not os.path.exists(cache_dir):
+        os.makedirs(cache_dir)
+    
+    if mode == 'r':
+        if pkg_name is None:
+            
+            pkl_path = f'{cache_dir}/{varible}.pkl'
+        else:
+            pkl_path = f'../{pkg_name}_pkg//{cache_dir[1:]}/{varible}.pkl'
+
+        with open(pkl_path, 'rb') as file:
+            var_value = pickle.load(file)
+            return var_value
+    
+    if var_name is None: # get the variable name by looping the parent function
+        # lcls = inspect.stack()[2][0].f_locals
+        # for name in lcls:
+        #     if id(varible) == id(lcls[name]):
+        #         var_name = name
+
+        stack = traceback.extract_stack()
+        filename, lineno, function_name, code = stack[-2]
+        var_name_raw = re.compile(r'\((.*?)\).*$').search(code).groups()[0] # the default name is everything in the bracket, like: 'None_0', mode='w'
+        var_name = var_name_raw.split(',')[0] 
+        pkl_path = f'{cache_dir}/{var_name}.pkl'
+
+    if var_name is None: # get the name by adding incremental number on the default name
+        # dir_path = os.path.dirname(os.path.realpath(__file__))
+        var_name = 'cached_variable'
+        for count_of_cached_obj in range(max_count):
+            pkl_path = f'{cache_dir}/{var_name}_{count_of_cached_obj}.pkl'
+            if not os.path.exists(pkl_path):
+                break
+        
+    with open(pkl_path, 'wb') as file:
+        pickle.dump(varible, file)
+
+    if print_on:
+        print(var_name+": ", varible)
+
+    print(f'[INFO]: the value of variable [{var_name}] has been cached under ./_cache_!')

mindsett_energy_reports_pkg/mdl/utils_/color_dict/__init__.py

@@ -0,0 +1,13 @@
+
+color_dict = {"tomato": '#FF836A',
+      "aquablue": '#6DC2B3',
+      "peach": '#FED6D2',
+      "darkgrey": '#9F9D9C',
+      "potato": '#FEF8C8',
+      "cyan": '#B6E4E1',
+     "Mindsett Blue": '#132F57',
+     "Black": '#000000',
+     "Mindsett Grey":'#b3b3b3',
+     "White": '#ffffff',
+     "Mindsett Green": '#00A19A',
+     "Mindsett Red":'#E6354C'}

mindsett_energy_reports_pkg/mdl/utils_/delete_files_in_directory/__init__.py

@@ -0,0 +1,15 @@
+
+
+import os
+
+def delete_files_in_directory(directory_path, ignore=[]):
+   try:
+     files = os.listdir(directory_path)
+     filtered_files = C = list(set(files) - set(ignore))
+     for file in filtered_files:
+       file_path = os.path.join(directory_path, file)
+       if os.path.isfile(file_path):
+         os.remove(file_path)
+     print(f"\nAll files in path [{directory_path}] were deleted successfully.")
+   except OSError:
+     print("Error occurred while deleting files.")

mindsett_energy_reports_pkg/mdl/utils_/enriching_time_features/__init__.py

@@ -0,0 +1,66 @@
+import pandas as pd
+
+def enriching_time_features(df_meta_with_value, period_freq='M', 
+                            schedule_records = None,
+                            ooh_values=['OUT OF HOURS', 'POST TRADE', 'closed'],
+                            weekend=None, 
+                            working_end_time=None, 
+                            working_start_time=None,
+                            timezone='UTC'):
+    
+    if weekend == None:
+        weekend = 5
+    if working_end_time == None:
+        working_end_time = "18:00:00"
+    if working_start_time == None:
+        working_start_time = "08:00:00"
+
+    # manipulate and clean the data
+
+    # print('df_meta_with_value.head(3).time: ', df_meta_with_value.head(3).time)
+
+    df_meta_with_value.time = pd.to_datetime(df_meta_with_value.time).dt.tz_convert(timezone)
+
+    # print('df_meta_with_value.head(3): ', df_meta_with_value.head(3)) # test
+    df_meta_with_value = df_meta_with_value.set_index("time") 
+
+    # enrich_time_information
+    df_meta_with_value["date"] = df_meta_with_value.index.date
+    df_meta_with_value["day_of_month"] = df_meta_with_value.index.day
+    df_meta_with_value["time_of_day"] = df_meta_with_value.index.time
+
+    df_meta_with_value['time_of_day_in_float'] = df_meta_with_value.index.hour+df_meta_with_value.index.minute/60+df_meta_with_value.index.second/3600
+
+    df_meta_with_value["weekday"] = df_meta_with_value.index.weekday
+    df_meta_with_value["day_name"] = df_meta_with_value.index.day_name()
+    df_meta_with_value["day_code"] = df_meta_with_value["day_name"].str[0]
+    df_meta_with_value["month"] = df_meta_with_value.index.month
+    df_meta_with_value["month_name"] = df_meta_with_value.index.month_name() #new change/implementation -RP
+
+    # print('schedule_records: ', schedule_records)
+
+    if schedule_records is not None:
+
+        df_meta_with_value["out_of_hours"] = False
+
+        for schedule_record in schedule_records:
+            # print('schedule_record: ', schedule_record)
+            if schedule_record['name'] in ooh_values:
+                df_meta_with_value["out_of_hours"] |= (df_meta_with_value['day_name'] == schedule_record['day']) & \
+                                                (df_meta_with_value["time_of_day"] >= schedule_record['start_time']) & \
+                                                (df_meta_with_value["time_of_day"] < schedule_record['end_time'])
+                
+                # print('ooh exist:', sr_ooh_record.unique())
+                ## For out of hour - POST TRADE, OUT OF HOUR
+                ## For In Hour - PRE TRADE, TRADE
+
+                # If out of hour - then run the below files,  checkpoint - POST TRADE & OUT OF HOUR
+                # if !out of hour - checkpoint - POST TRADE | OUT OF HOUR, run different file
+    else:
+        df_meta_with_value["out_of_hours"] = df_meta_with_value['weekday'].ge(weekend) | \
+                                                (df_meta_with_value["time_of_day"] > pd.to_datetime(working_end_time).time()) | \
+                                                (df_meta_with_value["time_of_day"] < pd.to_datetime(working_start_time).time())
+    
+    df_meta_with_value["period"] = df_meta_with_value.index.tz_localize(None).to_period(freq=period_freq)
+    
+    return df_meta_with_value

mindsett_energy_reports_pkg/mdl/utils_/enriching_time_features/__version__.py

@@ -0,0 +1,4 @@
+
+
+__version__ = '0.0.2' # add feature for patching missing period
+__version__ = '0.0.1' # initial version

mindsett_energy_reports_pkg/mdl/utils_/generate_time_partition_list/__init__.py

@@ -0,0 +1,14 @@
+import pandas as pd
+
+def generate_time_partition_list(time_range, freq='1D'):
+    
+    start_time_str = time_range[0]
+    end_time_str = time_range[1]
+    
+    time_list = pd.date_range(start=start_time_str, end=end_time_str, freq=freq).to_list()
+
+    time_str_list = [time.strftime("%Y-%m-%d %X%z") for time in time_list]
+
+    time_range_list = list(zip(time_str_list[:-1], time_str_list[1:]))
+    
+    return time_range_list

mindsett_energy_reports_pkg/mdl/utils_/get_group_with_others/__init__.py

@@ -0,0 +1,7 @@
+
+def get_group_with_others(row, asset_group):
+    if row["gt_pct_others"]:
+        return row[asset_group]
+    else:
+        return "Others"
+        

mindsett_energy_reports_pkg/mdl/utils_/get_pos_bot_range_unit_format/__init__.py

@@ -0,0 +1,37 @@
+
+from .get_pos_bot_and_ylim import get_pos_bot_and_ylim
+
+def get_pos_bot_range_unit_format(df_pivot_working_hours_sorted, 
+                                  pad_pct_above_max=None):
+
+    df_pivot_working_hours_sorted_reset = df_pivot_working_hours_sorted.reset_index(drop=True)
+
+    df_pivot_working_hours_sorted_reset_pos, \
+        df_pivot_working_hours_sorted_reset_bot, \
+            ytick_range = get_pos_bot_and_ylim(df_pivot_working_hours_sorted_reset,
+                                    pad_pct_above_max = pad_pct_above_max)
+
+    max_y_tick = max([abs(y_tick) for y_tick in ytick_range])
+
+    if max_y_tick > 0.1: # 100 kwh = 0.1 mwh as switching point for unit as kwh or mwh
+        display_unit = 'MWh'
+        formatter = '%.1f'
+        
+        #ax_l.set_yticks(np.arange(0, tick_range_e, 0.1))
+        # ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.1f'))
+    else:
+        df_pivot_working_hours_sorted_reset = df_pivot_working_hours_sorted_reset.mul(1000)
+
+        # after the change of units, the dfs and limits should be updated
+        df_pivot_working_hours_sorted_reset_pos, \
+            df_pivot_working_hours_sorted_reset_bot, \
+                ytick_range = get_pos_bot_and_ylim(df_pivot_working_hours_sorted_reset,
+                                    pad_pct_above_max = pad_pct_above_max)
+
+        display_unit = 'kWh'
+        formatter = '%.0f'
+        
+        #ax_l.set_yticks(np.arange(0, tick_range_e, 0.1))
+        # ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.0f'))
+
+    return df_pivot_working_hours_sorted_reset_pos, df_pivot_working_hours_sorted_reset_bot, ytick_range, display_unit, formatter

mindsett_energy_reports_pkg/mdl/utils_/get_pos_bot_range_unit_format/get_pos_bot_and_ylim/__init__.py

@@ -0,0 +1,31 @@
+
+
+def get_pos_bot_and_ylim(df_pivot_working_hours_sorted_reset,
+                         pad_pct_above_max = None):
+
+    if pad_pct_above_max is None:
+        pad_pct_above_max = 0.2
+
+    # make the index unique for later processing
+    df_pivot_working_hours_sorted_reset_pos = df_pivot_working_hours_sorted_reset[False]
+    sr_pivot_working_hours_sorted_reset_bot = df_pivot_working_hours_sorted_reset[True].sum(axis=1)
+
+    # get the maximum and minimum values
+    zero_line = 0
+    tick_value_e_max = max(zero_line, df_pivot_working_hours_sorted_reset.sum(axis=1).max()) # ensure that the 0 line is still showing
+    tick_value_e_min = min(zero_line, sr_pivot_working_hours_sorted_reset_bot.min()) # ensure that the 0 line is still showing
+    tick_value_e_var = tick_value_e_max - tick_value_e_min
+
+    # add padding to the boundary values to make the range
+    
+    if abs(tick_value_e_min) > (tick_value_e_max*0.01): # if the abs value of tick_value_e_min is very small, then set zero as the lowest range
+        pad_pct_below_min = 0.05
+    else:
+        pad_pct_below_min = 0
+
+    tick_range_e_max = tick_value_e_max + tick_value_e_var*pad_pct_above_max
+    tick_range_e_min = tick_value_e_min - tick_value_e_var*pad_pct_below_min
+
+    ls_ylim = [tick_range_e_min, tick_range_e_max]
+
+    return df_pivot_working_hours_sorted_reset_pos, sr_pivot_working_hours_sorted_reset_bot, ls_ylim

mindsett_energy_reports_pkg/mdl/utils_/modify_group_names/__init__.py

@@ -0,0 +1,17 @@
+
+# modify the names in asset_group based on the provided dictionary
+
+def modify_group_names(df_meta_with_value, group_name_column="asset_type", modification_dict={}):
+    
+    # the letter cases and spaces prefix/sufix will not affect the result
+    df_meta_with_value[group_name_column] = df_meta_with_value[group_name_column].str.strip()
+
+    modification_dict_with_lowercase_key = {}
+    for group in modification_dict:
+        modification_dict_with_lowercase_key[group.lower().strip()] = modification_dict[group]
+
+    df_meta_with_value[group_name_column] = df_meta_with_value[group_name_column] \
+                                                                            .str.lower() \
+                                                                            .map(modification_dict_with_lowercase_key) \
+                                                                            .fillna(df_meta_with_value[group_name_column])
+    return df_meta_with_value

mindsett_energy_reports_pkg/mdl/utils_/patch_missing_periods/__init__.py

@@ -0,0 +1,34 @@
+
+import pandas as pd
+
+def patch_missing_periods(df_source, start_time, end_time, 
+                          time_col='time',
+                          value_col='kwh',
+                          period_freq='W',
+                          timezone='UTC'):
+    
+    # print('start_time, end_time:', start_time, end_time)
+
+    end_time_inclusive = end_time - pd.Timedelta(microseconds=1)
+
+    # print('df_source: ', df_source.sort_values(by=['time'], ascending=False).head())
+    actual_periods_ls = pd.to_datetime(df_source.time, utc=True).dt.tz_convert(tz=timezone).dt.tz_localize(None).dt.to_period(freq=period_freq).unique()
+    expect_periods_ls = pd.period_range(start=start_time, end=end_time_inclusive, freq=period_freq)
+
+    # print('actual_periods_ls: ', actual_periods_ls)
+    # print('expect_periods_ls: ', expect_periods_ls)
+
+    for period_obj in expect_periods_ls:
+        if period_obj not in actual_periods_ls:
+            
+            print(f'There is no data in period {period_obj}. A placeholder with zero consumption has been added!')
+            print('start_time', period_obj.start_time)
+            df_placeholder = df_source.head(1)
+            with pd.option_context('mode.chained_assignment', None):
+                df_placeholder[value_col] = 0
+                df_placeholder[time_col] = pd.Timestamp(period_obj.start_time, tz=timezone)
+                df_source = pd.concat([df_source, df_placeholder], ignore_index=True)
+                df_source.loc[:, time_col] = pd.to_datetime(df_source[time_col], utc=True)
+    
+    # print('df_source: ', df_source.head())
+    return df_source

mindsett_energy_reports_pkg/mdl/utils_/plot_stacked_barchart/__init__.py

@@ -0,0 +1,50 @@
+
+import numpy as np
+
+def plot_stacked_barchart(ax, df_pivot_working_hours, bottom=None,
+                          tick_range=None,
+                          top_hours=None):
+
+    if tick_range is None:
+        tick_value_e_max = max(0, df_pivot_working_hours.sum(axis=1).max())
+        tick_value_e_min = min(0, df_pivot_working_hours.sum(axis=1).min())
+        tick_range = [tick_value_e_min, tick_value_e_max]
+
+    if bottom is None:
+        bottom = 0
+    if top_hours is None:
+        top_hours = True
+
+    tick_value_e_var = tick_range[1] - tick_range[0]
+    white_padding_below_bar = abs(tick_value_e_var/100)
+
+    bar_padding_adjustment = 0.01 # used when the paddings on the left/right are different
+    
+    bot_hours = not top_hours
+
+    bar_edgecolour = ['k','w']
+    bar_fillcolour = ['k','w']
+    bar_color = '#6DC2B3'
+
+    hours_labels = {True: "Out Of Hours", False: "In Hours"}
+    hours_colors = {True: "w", False: bar_color}
+
+    # white edge/pad of bar
+    ax.bar(df_pivot_working_hours.index, df_pivot_working_hours[top_hours].fillna(0)+df_pivot_working_hours[bot_hours].fillna(0),
+           bottom=bottom,
+           width=0.7, 
+           lw=1.3, 
+           edgecolor=bar_edgecolour[0], 
+           color=bar_fillcolour[1], 
+           label=hours_labels[top_hours])
+
+    # bottom bar inner part
+    inner_bar_bot_pad = tick_value_e_var*0.01
+    df_white_padding_below_bar_conditional = np.sign(df_pivot_working_hours[bot_hours])*(white_padding_below_bar+inner_bar_bot_pad)
+    ax.bar(df_pivot_working_hours.index+bar_padding_adjustment, df_pivot_working_hours[bot_hours].fillna(0) - df_white_padding_below_bar_conditional,
+           bottom=bottom+inner_bar_bot_pad,
+           width=0.4, 
+           lw=0, 
+           color= hours_colors[bot_hours], 
+           edgecolor=bar_edgecolour[1], 
+           label=hours_labels[bot_hours])

mindsett_energy_reports_pkg/mdl/utils_/send_email/__init__.py

@@ -0,0 +1,73 @@
+import smtplib
+from pathlib import Path
+from email.mime.multipart import MIMEMultipart
+from email.mime.base import MIMEBase
+from email.mime.text import MIMEText
+from email.utils import COMMASPACE, formatdate
+from email import encoders
+import io
+
+def send_email(send_from, send_to, subject, message, signature=None, cc=None, bcc=None, files={},
+              server="localhost", port=587, username='', password='',
+              use_tls=True):
+    """Compose and send email with provided info and attachments.
+
+    Args:
+        send_from (str): from name
+        send_to (list[str]): to name(s)
+        subject (str): message title
+        message (str): message body
+        files (dict{str:str|obj}): list of file paths to be attached to email
+        server (str): mail server host name
+        port (int): port number
+        username (str): server auth username
+        password (str): server auth password
+        use_tls (bool): use TLS mode
+    """
+    
+    msg = MIMEMultipart()
+    msg['From'] = send_from
+    msg['To'] = COMMASPACE.join(send_to)
+    
+    if cc is not None:
+        msg['Cc'] = COMMASPACE.join(cc)
+        
+    if bcc is not None:
+        msg['Bcc'] = COMMASPACE.join(bcc)
+        
+    msg['Date'] = formatdate(localtime=True)
+    msg['Subject'] = subject
+
+    html_msg = MIMEText(message, 'html')
+    msg.attach(html_msg)
+
+    if signature != None:
+        sgn = MIMEText(signature, "html")
+        msg.attach(sgn)
+
+    for filename in files:
+        part = MIMEBase('application', "octet-stream")
+
+        file_path_obj = files[filename]
+
+        if isinstance(file_path_obj, io.BytesIO):
+            part.set_payload(file_path_obj.getvalue())
+            encoders.encode_base64(part)
+            part.add_header('Content-Disposition',
+                            f'attachment; filename={filename}')
+        else:
+            with open(file_path_obj, 'rb') as file:
+                part.set_payload(file.read())
+            encoders.encode_base64(part)
+            part.add_header('Content-Disposition',
+                            f'attachment; filename={filename}')
+        msg.attach(part)
+
+    smtp = smtplib.SMTP(server, port)
+    if use_tls:
+        smtp.starttls()
+    smtp.login(username, password)
+    smtp.sendmail(send_from, send_to, msg.as_string())
+    smtp.quit()
+     
+    print(f'[smtp]: email sent successfully to {str(send_to)}!')

mindsett_energy_reports_pkg/mdl/utils_/setup_table/__init__.py

@@ -0,0 +1,40 @@
+
+from .check_table_existence import check_table_existence
+from .create_new_schema import create_new_schema
+from .empty_table import empty_table
+from .create_table import create_table
+
+def setup_table(engine, table_name, columns_dict, 
+                hypertable=False, 
+                index=None,
+                constraint=None,
+                redo_from_start=False, 
+                with_log=True):
+    """
+    Function Name: setup_table
+    Parameters   : sql connection engine, table name, redo_from_start flag
+    Description  : if redo from start set inconfiguration file - emptys table 
+                   otherwise creates a new table and schema if required 
+    """
+    
+    is_exist = check_table_existence(engine, table_name)
+    
+    if is_exist:
+        if redo_from_start:
+            empty_table(engine, table_name, 
+                        with_log=with_log)
+    else:
+        table_schema_name_list = table_name.split(".")
+
+        if len(table_schema_name_list) > 1:
+
+            # TODO: add check_schema_existence
+            table_schema = table_schema_name_list[0]
+            create_new_schema(engine, table_schema)
+        
+        create_table(engine, table_name, columns_dict, 
+                     constraint=constraint,
+                     index=index,
+                     hypertable=hypertable)
+        
+    return

mindsett_energy_reports_pkg/mdl/utils_/setup_table/check_table_existence/__init__.py

@@ -0,0 +1,25 @@
+def check_table_existence(engine, table_name):
+    
+    table_schema_name_list = table_name.split('.')
+
+    if len(table_schema_name_list) > 1:
+        table_schema = table_schema_name_list[0]
+        table_non_schema_name = table_schema_name_list[1]
+    else:
+        table_schema = 'public'
+        table_non_schema_name = table_name
+
+    query_check_existing_tables = f"""select table_name from information_schema.tables where table_schema = '{table_schema}' 
+    and table_name = '{table_non_schema_name}'"""
+
+    with engine.connect() as conn:
+        list_tables = conn.execute(query_check_existing_tables)
+
+    table_name_list = [table_name[0] for table_name in list_tables]
+
+    if len(table_name_list) == 1:
+        # print(f'The table [{table_name}] already exists')
+        return True
+    else:
+        # print(f'The table [{table_name}] does not exist')
+        return False

mindsett_energy_reports_pkg/mdl/utils_/setup_table/create_new_schema/__init__.py

@@ -0,0 +1,8 @@
+def create_new_schema(engine, schema_name):
+    
+    with engine.connect() as conn:
+        query_create_schema = f"""CREATE SCHEMA IF NOT EXISTS {schema_name};"""
+        conn.execute(query_create_schema) 
+    
+    print(f'New schema [{schema_name}] is created.')
+    return

mindsett_energy_reports_pkg/mdl/utils_/setup_table/create_table/__init__.py

@@ -0,0 +1,73 @@
+
+
+def create_table(engine, table_name, columns_dict, hypertable=False, time_column='time', index=None, constraint=None):
+    """
+    Function Name: create_table
+    Parameters   : sql connection engine, table name, column dictionay, hypertable required flag
+    Description  : creates a new table 
+    
+    """
+    
+    if hypertable:     
+        if time_column not in columns_dict:
+            raise "For hypertable requires a valid time column in columns_dict defined with schema timestamp"
+    
+    with engine.connect() as conn: 
+        
+        if hypertable:
+            # enable the timescaledb extension, so function create_hypertable can be used
+            query_create_extensions = "CREATE EXTENSION IF NOT EXISTS timescaledb;" 
+            conn.execute(query_create_extensions)
+        
+        columns_list = [f"{column_name} {columns_dict[column_name]}" for column_name in columns_dict]
+        
+        query_columns_statement = ", ".join(columns_list)
+        
+        query_create_normaltable = f"""CREATE TABLE {table_name} ({query_columns_statement});"""
+
+        conn.execute(query_create_normaltable)
+
+        table_feature_statement = ''
+        
+        if hypertable:
+            query_create_hypertable = f"SELECT create_hypertable('{table_name}', '{time_column}');"
+            conn.execute(query_create_hypertable)
+            table_feature_statement += ', as hypertable'
+
+        if index is not None:
+            index_name = list(index)[0]
+            if isinstance(index[index_name], list):
+                index_columns_list = index[index_name]
+            else:
+                index_columns_list = [index[index_name]] # convert variable to list
+
+            index_columns_str = ", ".join(index_columns_list)
+
+            query_create_index = f"CREATE INDEX {index_name} ON {table_name} ({index_columns_str});"
+            conn.execute(query_create_index)
+            table_feature_statement += f', with index: {index_name} - [{index_columns_str}]'
+
+        if constraint is not None:
+            for constraint_name in list(constraint):
+                if isinstance(constraint[constraint_name], list):
+                    constraint_columns_list = constraint[constraint_name]
+                else:
+                    constraint_columns_list = [constraint[constraint_name]] # convert variable to list
+
+                constraint_columns_str = ", ".join(constraint_columns_list)
+
+                query_create_constraint = f"ALTER TABLE {table_name} ADD CONSTRAINT {constraint_name} UNIQUE ({constraint_columns_str});"
+                
+                # print('query_create_constraint: ', query_create_constraint)
+                conn.execute(query_create_constraint)
+
+                table_feature_statement += f', with constraint: {constraint_name} - [{constraint_columns_str}]'
+                # conn.commit()
+
+                # example:
+                # ALTER TABLE table_name
+                # ADD CONSTRAINT constraint_name
+                # UNIQUE(column1,column2,..)
+
+    print(f'New table [{table_name}] is created' + table_feature_statement + '.')
+    return

mindsett_energy_reports_pkg/mdl/utils_/setup_table/empty_table/__init__.py

@@ -0,0 +1,11 @@
+def empty_table(engine, table_name, with_log=True):
+    
+    with engine.connect() as conn:
+
+        # delete data (empty) in the table
+        query_empty_table = f"""DELETE FROM {table_name};"""
+        conn.execute(query_empty_table) 
+
+    if with_log:
+        print(f'The table [{table_name}] is empty now.')
+    return