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

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_period_barchart/plot_shifted_period_barchart/set_x_tick_and_lim/__init__.py

@@ -0,0 +1,26 @@
+import matplotlib.ticker as ticker
+
+def set_x_tick_and_lim(ax, x_ticks_labels, df_pivot_working_hours_sorted,
+                       fontsize=None):
+
+    if fontsize is None:
+        fontsize = 13
+
+    df_pivot_working_hours_sorted_reset = df_pivot_working_hours_sorted.reset_index(drop=True)
+
+    # set up the x-ticks and xlim
+    ax.tick_params(axis='x', which='major', pad=8, length=2, labelsize=fontsize)
+
+    x_tick_pad =  0.99
+    top_index = df_pivot_working_hours_sorted_reset.index.min() - x_tick_pad
+    bot_index = df_pivot_working_hours_sorted_reset.index.max() + x_tick_pad
+    ax.set_xlim([top_index, bot_index])
+
+    # used to handle the below warning:
+    ax.xaxis.set_major_locator(ticker.MultipleLocator(1)) # ValueError: The number of FixedLocator locations (5), usually from a call to set_ticks, does not match the number of labels (8).
+
+    # fixing yticks with matplotlib.ticker "FixedLocator": UserWarning: FixedFormatter should only be used together with FixedLocator
+    ticks_loc = ax.get_xticks().tolist()
+    # print(f'{ticks_loc = }')
+    ax.xaxis.set_major_locator(ticker.FixedLocator(ticks_loc))
+    ax.set_xticklabels(x_ticks_labels, fontsize=fontsize)   

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_period_barchart/plot_shifted_period_barchart/setup_y_tick_lim_label_zero_line/__init__.py

@@ -0,0 +1,31 @@
+import matplotlib.ticker as ticker
+
+def setup_y_tick_lim_label_zero_line(ax, ls_ylim, display_unit, formatter, 
+                                     freqstr=None,
+                                     fontsize=None):
+
+    if freqstr is None:
+        freqstr == 'M'
+
+    if fontsize is None:
+        fontsize = 13
+
+    # move the y_tick to the right
+    ax.yaxis.tick_right()
+    ax.yaxis.set_label_position("right")
+    ax.tick_params(axis='y', which='major', pad=9, length=5, labelsize=fontsize)
+    ax.set_ylim(ls_ylim)
+
+    # set y label
+    if freqstr == 'M':
+        y_label = f"Monthly Usage ({display_unit})"
+    else:
+        y_label = f"Weekly Usage ({display_unit})"
+
+    ax.set_ylabel(y_label, labelpad= 18, fontsize =fontsize)
+
+    # set yaxis formatter
+    ax.yaxis.set_major_formatter(ticker.FormatStrFormatter(formatter))
+
+    # plot the zero value horizontal line
+    ax.axhline(y=0, color='k', linestyle=':', zorder=-1)

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_period_barchart/preprocessing_for_period_barchart/__init__.py

@@ -0,0 +1,43 @@
+import pandas as pd
+from itertools import product
+
+from .patch_missing_ooh_periods_sign import patch_missing_ooh_periods_sign
+
+def preprocessing_for_period_barchart(df_meta_with_value,
+                                      sign_column=None,
+                                        period_column=None, 
+                                        ooh_column=None, 
+                                        kwh_column=None,
+                                        no_of_period=None):
+    if sign_column is None:
+        sign_column = 'neg_sign'
+
+    if period_column is None:
+        period_column = "period"
+    
+    if ooh_column is None:
+        ooh_column = "out_of_hours"
+
+    if  kwh_column is None:
+        kwh_column = "kwh"
+
+    if no_of_period is None:
+        no_of_period = 6
+
+    df_meta_with_value[sign_column] = df_meta_with_value[kwh_column].lt(0)
+
+    df_grouped_working_hours_period = df_meta_with_value.groupby([sign_column, period_column, ooh_column])[kwh_column].sum()
+
+    period_max = df_meta_with_value[period_column].max() # todo: check whether there are other better ways for getting the max period, as it might be missing also
+
+    # handle the situation that not all groups exist
+    df_grouped_working_hours_period = patch_missing_ooh_periods_sign(df_grouped_working_hours_period, period_max,
+                                                                    no_of_period=no_of_period)
+
+    df_grouped_working_hours_period_unstacked = df_grouped_working_hours_period.unstack([sign_column, ooh_column])
+    df_grouped_working_hours_period_unstacked = df_grouped_working_hours_period_unstacked.sort_index()
+
+    # convert the unit from kwh to mwh
+    df_grouped_working_hours_period_unstacked = df_grouped_working_hours_period_unstacked.div(1000)
+    
+    return df_grouped_working_hours_period_unstacked

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_period_barchart/preprocessing_for_period_barchart/patch_missing_ooh_periods_sign/__init__.py

@@ -0,0 +1,23 @@
+
+import pandas as pd
+from itertools import product
+
+def patch_missing_ooh_periods_sign(df_grouped_working_hours_period,
+                                  period_max,
+                                  no_of_period=None):
+    
+    if no_of_period is None:
+        no_of_period = 6
+
+    # handle the situation that not all groups exist
+    expected_sign = [True, False]
+    expected_periods = [period_max-i for i in range(no_of_period)]
+    expected_working_hours = [True, False]
+    expected_group_index = pd.Index(product(expected_sign, expected_periods, expected_working_hours))
+
+    missing_group_index = expected_group_index.drop(df_grouped_working_hours_period.index)
+
+    for indice in missing_group_index:
+        df_grouped_working_hours_period.loc[indice] = 0
+
+    return df_grouped_working_hours_period

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/__init__.py

@@ -0,0 +1,56 @@
+
+import io
+import matplotlib.pyplot as plt
+
+
+from .preprocessing_for_piechart import preprocessing_for_piechart
+from .preprocessing_for_phases import preprocessing_for_phases
+from .plot_adaptive_ring_with_phase import plot_adaptive_ring_with_phase
+
+
+def generate_piechart_with_phase(df_meta_with_value,
+                      colors=None,
+                      hatches=None,
+                      reading_interval_in_mins=None,
+                      asset_group=None,
+                      minimum_cnt_for_protection=None,
+                      max_display_cnt=None,
+                      sum_column=None, 
+                      pct_column=None,
+                      gene_column=None,
+                      fontsize=None,
+                      directory_to_savefig=None
+                      ):
+
+    df_sort_idx_trim = preprocessing_for_piechart(df_meta_with_value,
+                                                reading_interval_in_mins=reading_interval_in_mins,
+                                                asset_group=asset_group,
+                                                minimum_cnt_for_protection=minimum_cnt_for_protection,
+                                                    max_display_cnt=max_display_cnt,
+                                                    sum_column=sum_column, 
+                                                    pct_column=pct_column,
+                                                    gene_column=gene_column)
+    
+    phase_values_list = preprocessing_for_phases(df_meta_with_value,
+                                                 reading_interval_in_mins=reading_interval_in_mins)
+
+    plot_adaptive_ring_with_phase(df_sort_idx_trim, phase_values_list,
+                                    colors=colors,
+                                    hatches=hatches,
+                                    sum_column=sum_column, 
+                                    pct_column=pct_column,
+                                    gene_column=gene_column,
+                                    fontsize=fontsize,
+                                    )
+
+    png_name = 'consumption_by_assetclass_piechart_with_phase.png'
+    if directory_to_savefig == None:
+        png_object = io.BytesIO()
+        plt.savefig(png_object, format='png', dpi=200)
+        plt.close()
+        return {png_name: png_object}
+    else:
+        png_path = directory_to_savefig + png_name
+        plt.savefig(png_path, format='png', dpi=200)
+        plt.close()
+        return {png_name: png_path}

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/__init__.py

@@ -0,0 +1,109 @@
+
+import matplotlib.pyplot as plt
+
+from .plot_ring import plot_ring
+from .plot_centre_pct import plot_centre_pct
+from .show_legend import show_legend
+from .plot_phase_balance import plot_phase_balance
+
+# cd = {"tomato": '#FF836A',
+#       "aquablue": '#6DC2B3',
+#       "peach": '#FED6D2',
+#       "darkgrey": '#9F9D9C',
+#       "potato": '#FEF8C8',
+#       "cyan": '#B6E4E1',
+#       "dimgray":'#696969',
+#       "Seafoam":'#87e0cf',
+#       "gainsboro":'#DCDCDC',
+#       "grey": '#808080',
+#       "brown": '#964B00',
+#       "black": '#000000'}
+
+def plot_adaptive_ring_with_phase(df_pre_pie,
+                                    phase_values_list,
+                                    colors=None,
+                                    hatches=None,
+                                    sum_column = None, 
+                                    pct_column = None,
+                                    gene_column = None,
+                                    fontsize=None,
+                                    ):
+    
+    if colors is None:
+        from .colors import colors
+
+    if hatches is None:
+        from .hatches import hatches
+    
+    if sum_column is None:
+        sum_column = "sum_abs"
+
+    if gene_column is None:
+        gene_column = 'generator'
+
+    fig, ax = plt.subplots(1, 1, figsize=(9, 3.5))
+
+    # gs = fig.add_gridspec(2, hspace=0)
+    # axs = gs.subplots(sharex=True, sharey=True)
+
+    if df_pre_pie[gene_column].nunique() == 2:
+
+        sr_outer = df_pre_pie.loc[df_pre_pie[gene_column]==False, sum_column]
+        sr_inner = df_pre_pie.loc[df_pre_pie[gene_column]==True, sum_column]
+        gap_value = sr_inner.sum() - sr_outer.sum()
+        outer_ring_inner_radius = 0.55
+        asset_total = sr_inner.sum() + sr_outer.sum()
+    else:
+        sr_outer = df_pre_pie[sum_column]
+        gap_value = None
+        outer_ring_inner_radius = 0.50
+        asset_total = sr_outer.sum()
+    
+    print('consumption_mwh_subchannel_sum: ', asset_total/1000) # debug
+
+    # plot the outer ring
+    plot_ring(sr_outer, ax,
+                    colors=colors, 
+                    fontsize=fontsize, 
+                    gap_value=gap_value, 
+                    outer_radius=1, 
+                    inner_radius=outer_ring_inner_radius,
+                    ann_pct=True, 
+                    as_inner_ring=False)
+
+    # plot the inner ring and pct text in the middle conditionally
+    if df_pre_pie[gene_column].nunique() == 2:
+        plot_ring(sr_inner, ax, 
+                        hatch=hatches, 
+                        fontsize=fontsize, 
+                        gap_value=-gap_value, 
+                        outer_radius=0.5, 
+                        inner_radius=0.3,
+                        ann_pct=False, 
+                        as_inner_ring=True)
+
+        assets_source_pct = sr_inner.sum()/sr_outer.sum()
+        plot_centre_pct(ax, assets_source_pct, 
+                        fontsize=fontsize)
+
+    show_legend(ax, df_pre_pie, 
+                fontsize=fontsize,
+                sum_column=sum_column, 
+                pct_column=pct_column)
+
+    # ruler settings
+    ru_x = 0.01  # the x-axis of phase balance ruler
+    ru_y = 0  # the x-axis of phase balance ruler
+    ru_w = 2  # the width of phase balance ruler
+    ru_h = 0.06 # the height of phase balance ruler
+
+    plot_phase_balance(ax, phase_values_list,
+                        fontsize=fontsize,
+                        ru_x=ru_x,
+                        ru_y=ru_y,
+                        ru_h=ru_h,
+                        ru_w=ru_w)
+
+    fig.tight_layout(pad=0, rect=[-0.2, -0.0, 0.608, 0.99])
+
+    ax.set_ylim(-1.75, 1.6)

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/colors/__init__.py

@@ -0,0 +1,28 @@
+
+
+colors = ['#6DC2B3', 
+          '#FF836A', 
+          '#FED6D2', 
+          '#9F9D9C', 
+          '#B6E4E1', 
+          '#FEF8C8', 
+          '#CFCDCD', 
+          '#9DE7BE', 
+          '#f7baad', 
+          '#b3fff2', 
+          '#F7D8BA']
+
+# backup/archive copy
+
+cd = {"aquablue": '#6DC2B3',
+      "tomato": '#FF836A',
+      "peach": '#FED6D2',
+      "darkgrey": '#9F9D9C',
+      "cyan": '#B6E4E1',
+      "potato": '#FEF8C8',
+      "dimgray":'#696969',
+      "Seafoam":'#87e0cf',
+      "gainsboro":'#DCDCDC',
+      "grey": '#808080',
+      "brown": '#964B00',
+      "black": '#000000'}

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/hatches/__init__.py

@@ -0,0 +1,2 @@
+
+hatches = ['oo', '..', '**', 'OO', '++', 'xx', '//', '\\\\', '||', '--']

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/plot_centre_pct/__init__.py

@@ -0,0 +1,28 @@
+
+import matplotlib.pyplot as plt
+
+
+
+def plot_centre_pct(ax, assets_source_pct, 
+                    fontsize=None):
+
+    if fontsize is None:
+        fontsize = 13
+    
+    assets_source_pct_value = assets_source_pct*100 
+
+    # print(f'{assets_source_pct_value = }')
+    # ensure the digits are readable
+    if assets_source_pct_value >= 1:
+        assets_source_pct_fmt = f'{assets_source_pct_value:.0f}%'
+    elif assets_source_pct_value >= 0.1:
+        assets_source_pct_fmt = f'{assets_source_pct_value:.1f}%'
+    elif assets_source_pct_value >= 0.01:
+        assets_source_pct_fmt = f'{(assets_source_pct_value*10):.1f}‰'
+    else:
+        assets_source_pct_fmt = f'<0.1‰'
+
+    ax.text(0, 0, assets_source_pct_fmt, 
+            fontsize=fontsize,
+            horizontalalignment='center',
+            verticalalignment='center')

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/plot_phase_balance/__init__.py

@@ -0,0 +1,42 @@
+
+# import matplotlib.patches as mpatches
+
+from .plot_phase_balance_part import plot_phase_balance_part
+from .get_tick_values import get_tick_values
+from .get_phase_markers import get_phase_markers
+
+color_dict = {"grey":  '#808080',
+              "brown": '#964B00',
+              "black": '#000000'}
+
+def plot_phase_balance(ax, phase_values_list,
+                    fontsize=None,
+                    ru_x=None,
+                    ru_y=None,
+                    ru_h=None,
+                    ru_w=None):
+    
+    phase_markers_list = get_phase_markers(phase_values_list)
+
+    part_control_ls = [{'ruler_part_color': color_dict["brown"],
+                        'phase_marker': phase_markers_list[0],
+                         'part': 'part_one',
+                         'part_idx': 1},
+                        {'ruler_part_color': color_dict["black"],
+                        'phase_marker': phase_markers_list[1],
+                         'part': 'part_two',
+                         'part_idx': 2},
+                        {'ruler_part_color': color_dict["grey"],
+                        'phase_marker': phase_markers_list[2],
+                         'part': 'part_three',
+                         'part_idx': 3}]
+    
+    ticks_values_list = get_tick_values(phase_values_list)
+
+    for part_control in part_control_ls:
+        plot_phase_balance_part(ax, ticks_values_list, part_control,
+                                fontsize=fontsize,
+                                ru_x=ru_x,
+                                ru_y=ru_y,
+                                ru_h=ru_h,
+                                ru_w=ru_w)

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/plot_phase_balance/get_phase_markers/__init__.py

@@ -0,0 +1,28 @@
+
+
+def get_phase_markers(phase_values_list, 
+                      var_allowance_pct=None):
+
+    balanced_avg_value = sum(phase_values_list)/3
+
+    if var_allowance_pct is None:
+        var_allowance_pct = 0.04
+
+    var_allowance_value = balanced_avg_value * var_allowance_pct
+
+    markers_list = []
+    for phase_value in phase_values_list:
+
+        if phase_value > (balanced_avg_value + var_allowance_value):
+            marker_text = '>'
+        elif phase_value > (balanced_avg_value - var_allowance_value):
+            marker_text = '='
+        elif phase_value > 0:
+            marker_text = '<'
+        else:
+            marker_text = '?'
+
+        markers_list.append(marker_text)
+    
+    return markers_list
+        

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/plot_phase_balance/get_tick_values/__init__.py

@@ -0,0 +1,44 @@
+
+import pandas as pd
+
+def get_tick_values(phase_values_list,
+                    min_visible_pct=None):
+
+    if min_visible_pct is None:
+        min_visible_pct = 0.077
+
+    df_phase = pd.DataFrame({'phase_value': phase_values_list})
+
+    total_value = df_phase['phase_value'].sum()
+
+    # setup the threshold
+    min_visible_value = total_value * min_visible_pct
+
+    # label the visibility
+    df_phase['min_visible_value'] = min_visible_value
+    df_phase['visible'] = df_phase['phase_value'].gt(min_visible_value)
+
+    # separate by visibility
+    df_phase_visible = df_phase.loc[df_phase['visible']]
+    df_phase_invisible = df_phase.loc[~df_phase['visible']]
+
+    # get adjusted value for invisible part
+    df_phase_invisible['adj_value'] = df_phase_invisible['min_visible_value']
+
+    # get adjusted value for visible part
+    compensation = df_phase_invisible['adj_value'].sum() - df_phase_invisible['phase_value'].sum()
+    visible_orig_sum = df_phase_visible['phase_value'].sum()
+    shrink_pct = (visible_orig_sum - compensation)/visible_orig_sum
+    df_phase_visible['adj_value'] = df_phase_visible['phase_value'] * shrink_pct
+
+    # combine the visible and invisible parts back
+    df_phase_adj = pd.concat([df_phase_visible, df_phase_invisible]).sort_index()
+
+    # get the tick values
+    df_phase_adj['tick_value'] = df_phase_adj['adj_value'].cumsum()
+
+    non_zero_tick_values = df_phase_adj['tick_value'].to_list()
+
+    tick_values_list = [0, *non_zero_tick_values]
+
+    return tick_values_list

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/plot_phase_balance/plot_phase_balance_part/__init__.py

@@ -0,0 +1,108 @@
+
+import matplotlib.patches as mpatches
+
+from .ruler_anno_shink_cf import ruler_anno_shink_cf
+
+def plot_phase_balance_part(ax, ticks_values_list, part_control,
+                         fontsize=None,
+                         fx=None,
+                         fy=None,
+                         fs=None,
+                         ru_x=None,
+                         ru_y=None,
+                         ru_h=None,
+                         ru_w=None):
+
+    if fontsize is None:
+        fontsize = 13
+
+    # fancy box setting
+    if fx is None:
+        fx = -1  # fancy box x-axis value
+    if fy is None:
+        fy = -1.3  # fancy box y-axis value
+    if fs is None:
+        fs = 1  # fancy box scale factor
+
+    # ruler settings
+    if ru_x is None:
+        ru_x = 0  # the x-axis of benchmarking ruler
+    if ru_y is None:
+        ru_y = 0  # the x-axis of benchmarking ruler
+    if ru_h is None:
+        ru_h = 0.03  # the height of benchmarking ruler
+    if ru_w is None:
+        ru_w = 1  # the width of benchmarking ruler
+
+    ruler_part_color = part_control['ruler_part_color']
+    part = part_control['part']
+    part_idx = part_control['part_idx']
+    phase_marker = part_control['phase_marker']
+    # text_color = part_control['text_color']
+
+    # ticks range
+    ticks_max = max(ticks_values_list)
+    ticks_min = min(ticks_values_list)
+    ticks_range = ticks_max - ticks_min
+    
+    # rp_edgecolor = 'k' # edgecolor of the ruler body parts
+    rp_note_fontsize = fontsize - 5 # the fontsize of notes on ruler parts # please note that the other sizes except default 13 haven't been tested yet
+
+    # ruler body - rectangle bar
+    rp_x = ru_x + ru_w * (ticks_values_list[part_idx-1]-ticks_min)/ticks_range       # the x-axis value of this part
+    rp_y = ru_y - 0.03 # - 0.1 # 0.14      # the y-axis value of this part
+    rp_pct = (ticks_values_list[part_idx]-ticks_values_list[part_idx-1])/ticks_range
+    rp_w = ru_w * rp_pct   # the width value of this part
+    rp_h = ru_h
+    rp_c = ruler_part_color
+    ruler_body_part = mpatches.Rectangle([fx+rp_x*fs, fy+rp_y*fs], rp_w*fs, rp_h*fs, 
+                                         facecolor=rp_c, 
+                                         edgecolor='w', 
+                                         lw=2)
+    ax.add_artist(ruler_body_part)
+
+    # ruler body - annotation on the bar
+    rpa_x = rp_x + rp_w/2.0 # ruler body part annotation - x axis
+    rpa_y = rp_y + 0.076 # ruler body part annotation - y axis
+    bar_width = rp_w*fs
+    # part = 'part_one'
+    rpa_text = ruler_anno_shink_cf(bar_width, part)
+    
+    ax.annotate(rpa_text, (fx+fs*rpa_x, fy+fs*rpa_y), 
+                color= 'w', # '#B87333', # text_color, 
+                weight='extra bold', 
+                fontsize=rp_note_fontsize, 
+                ha='center', 
+                va='center')
+    
+    # ruler body - marker symbol below the bar
+    rps_x = rp_x + rp_w/2.0 # ruler body part annotation - x axis
+    sym_pad_y = (-0.18)
+    rps_y = rp_y + sym_pad_y  # ruler body part annotation - y axis
+    bar_width = rp_w*fs
+    rp_maker_fontsize = fontsize +2 # make it bigger than the annotation text, to be more visible
+
+    # print(f'{rp_pct = }')
+
+    # balance_value = 1./3
+    # variance_allowance = 0.04/3
+
+    # if rp_pct > (balance_value + variance_allowance):
+    #     rps_text = '>'
+    # elif rp_pct > (balance_value - variance_allowance):
+    #     rps_text = '='
+    # elif rp_pct > 0:
+    #     rps_text = '<'
+    # else:
+    #     rps_text = '?'
+
+    # rpa_text = ruler_anno_shink_cf(bar_width, part)
+    symbol_color = 'k'
+    
+    ax.annotate(phase_marker, (fx+fs*rps_x, fy+fs*rps_y), 
+                color=symbol_color, 
+                weight='extra bold', 
+                fontsize=rp_maker_fontsize, 
+                ha='center', 
+                va='center')
+    

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/plot_phase_balance/plot_phase_balance_part/ruler_anno_shink_cf/__init__.py

@@ -0,0 +1,29 @@
+
+
+# ruler annotation shinking config
+
+config_dict = {'full_name': {'size_lim': 0.11*2, 
+                             'names': {'part_one': "", 
+                                       'part_two': '', 
+                                       'part_three': ''}},
+               'short_name':  {'size_lim': 0.035*2, 
+                               'names': {'part_one': "", 
+                                       'part_two': '', 
+                                       'part_three': ''}},
+               'null_name':  {'size_lim': 0.03*2, 
+                              'names': {'part_one': "", 
+                                        'part_two': '', 
+                                        'part_three': ''}},
+               }
+
+
+def ruler_anno_shink_cf(bar_width, part):
+
+    if bar_width > config_dict['full_name']['size_lim']:
+        rpa_text = config_dict['full_name']['names'][part]
+    elif bar_width > config_dict['short_name']['size_lim']:
+        rpa_text = config_dict['short_name']['names'][part]
+    else:
+        rpa_text = config_dict['null_name']['names'][part]
+
+    return rpa_text

mindsett_energy_reports_pkg/mdl/prepare_and_email_reports/prepare_report/generate_components/generate_piechart_with_phase/plot_adaptive_ring_with_phase/plot_phase_balance/plot_phase_balance_part/ruler_symbol_cf/__init__.py

@@ -0,0 +1,35 @@
+
+
+# ruler annotation shinking config
+
+config_dict = {'full_name': {'size_lim': 0.11, 
+                             'names': {'part_one': "L1", 
+                                       'part_two': 'L2', 
+                                       'part_three': 'L3'}},
+               'shrink_name':  {'size_lim': 0.08, 
+                                'names': {'part_one': "L1", 
+                                       'part_two': 'L2', 
+                                       'part_three': 'L3'}},
+               'short_name':  {'size_lim': 0.06, 
+                               'names': {'part_one': "1", 
+                                       'part_two': '2', 
+                                       'part_three': '3'}},
+               'null_name':  {'size_lim': 0.05, 
+                              'names': {'part_one': "", 
+                                        'part_two': '', 
+                                        'part_three': ''}},
+               }
+
+
+def ruler_anno_shink_cf(bar_width, part):
+
+    if bar_width > config_dict['full_name']['size_lim']:
+        rpa_text = config_dict['full_name']['names'][part]
+    elif bar_width > config_dict['shrink_name']['size_lim']:
+        rpa_text = config_dict['shrink_name']['names'][part]
+    elif bar_width > config_dict['short_name']['size_lim']:
+        rpa_text = config_dict['short_name']['names'][part]
+    else:
+        rpa_text = config_dict['null_name']['names'][part]
+
+    return rpa_text