PySimpleGUI/readme_creator/run_me.py

import re,datetime,time,os,platform,json,PySimpleGUI as sg; from subprocess import Popen; from make_real_readme import main
cd = os.path.dirname(os.path.abspath(__file__))

def readfile(filename):
    with open(filename, 'r', encoding='utf-8') as ff: return ff.read()
def writefile(fpath, content):
    with open(fpath, 'w', encoding='utf-8') as ff: ff.write(content)
def writejson(a_path:str, a_dict:dict) -> None:
    with open(a_path, 'w', encoding='utf-8') as output_file: json.dump(a_dict, output_file, ensure_ascii=False, indent=2)
def readjson(a_path:str) -> dict:
    with open(a_path, 'r', encoding='utf-8') as f: return json.load(f)


def openfile(a_path):
    # File exists?
    if not os.path.exists(a_path): return sg.Popup(f"Error! This file doesn't exists: {a_path}")

    # check: OS
    if 'Windows' in platform.system():
        os.startfile(a_path)

    elif 'Linux' in platform.system():
        Popen(f'exo-open "{a_path}"', shell=True)

def opendir(a_path):
    # Folder exists?
    if not os.path.exists(a_path): return sg.Popup(f"Error! This directory doesn't exists: {a_path}")

    # check: OS
    if 'Windows' in platform.system():
        os.startfile(a_path)

    elif 'Linux' in platform.system():
        Popen(f'exo-open --launch FileManager --working-directory "{a_path}"', shell=True)


########################################################################
#                              __ _            _                       #
#                             / _(_)          | |                      #
#    __   __   ___ ___  _ __ | |_ _  __ _     | |__   ___ _ __ ___     #
#    \ \ / /  / __/ _ \| '_ \|  _| |/ _` |    | '_ \ / _ \ '__/ _ \    #
#     \ V /  | (_| (_) | | | | | | | (_| |    | | | |  __/ | |  __/    #
#      \_/    \___\___/|_| |_|_| |_|\__, |    |_| |_|\___|_|  \___|    #
#                                    __/ |                             #
#                                   |___/                              #
########################################################################
def load_configs(): return readjson(os.path.join(cd, 'app_configs.json'))
def save_configs(a_config:dict): writejson(os.path.join(cd, 'app_configs.json'), a_config)



APP_CONFIGS = load_configs()
README_OFILENAME = APP_CONFIGS['README_FILENAME']
CALL_REFERENCE_OFILENAME = APP_CONFIGS['CALL_REFERENCE_FILENAME']


##-#-#-# ##-#-#-#
# Post-process logic
##-#-#-# ##-#-#-#
insert_md_section_for__class_methods = False
remove_repeated_sections_classmethods = False

class BESTLOG(object):
    def __init__(self, filename):
        # my_file = logging.FileHandler(filename, mode='w')
        # my_file.setLevel(logging.DEBUG)
        # my_file.setFormatter(logging.Formatter('%(asctime)s>%(levelname)s: %(message)s'))
        # logger = logging.getLogger(__name__)
        # logger.setLevel(logging.DEBUG)
        # logger.addHandler(my_file)
        self.filename = filename
        self.json_name = filename + '.json'
        self.error_list = []
        self.warning_list = []
        self.info_list = []
        self.debug_list = []
        self.tick_amount=1
        self.names = self.messages_names = 'error warning info debug'.split(' ')

    def tick(self):
        self.tick_amount+=1
        return self.tick_amount

    #######################################################################
    #      __             _                             _ _               #
    #     / _|           | |                           (_) |              #
    #    | |_ ___  _ __  | |_ _ __ __ _ _ __  ___ _ __  _| | ___ _ __     #
    #    |  _/ _ \| '__| | __| '__/ _` | '_ \/ __| '_ \| | |/ _ \ '__|    #
    #    | || (_) | |    | |_| | | (_| | | | \__ \ |_) | | |  __/ |       #
    #    |_| \___/|_|     \__|_|  \__,_|_| |_|___/ .__/|_|_|\___|_|       #
    #                                            | |                      #
    #                                            |_|                      #
    #######################################################################
    def error(self, m):     self.error_list.append([self.tick(), m])
    def warning(self, m):   self.warning_list.append([self.tick(), m])
    def info(self, m):      self.info_list.append([self.tick(), m])
    def debug(self, m):     self.debug_list.append([self.tick(), m])

    ##########################################
    #      __                                #
    #     / _|                               #
    #    | |_ ___  _ __   _ __ ___   ___     #
    #    |  _/ _ \| '__| | '_ ` _ \ / _ \    #
    #    | || (_) | |    | | | | | |  __/    #
    #    |_| \___/|_|    |_| |_| |_|\___|    #
    #                                        #
    #                                        #
    ##########################################
    def tolist(self):    return zip([self.error_list, self.warning_list, self.info_list, self.debug_list], self.names)
    def todict(self):    return {'error' : self.error_list, 'warning' : self.warning_list, 'info' : self.info_list, 'debug' : self.debug_list}
    
    def save(self):
        all_messages_list = []
        for messages, message_type in self.tolist():
            all_messages_list.extend([{'message_type' : message_type, 'message_text' : m_text, 'message_time' : m_time} for m_time, m_text in messages])

        # sort messages on time
        all_messages_list = sorted(all_messages_list, key=lambda x: x['message_time'])
        
        # convert time
        # for i in all_messages_list: i['message_time'] = i['message_time'].strftime('%Y-%m-%d %H:%M:%S.%f')

        writejson(self.json_name, all_messages_list)
    def load(self, **kw):
        '''
            return dict with messages
            
            kw = {
                use_psg_color : bool
                show_time : bool
            }
        '''

        # plan:
        # read json, convert time

        # read
        all_messages_list = readjson(self.json_name)
        # convert time
        # for i in all_messages_list: i['message_time'] = datetime.datetime.strptime(i['message_time'], '%Y-%m-%d %H:%M:%S.%f')

        def format_message(message):
            if kw['show_time']:
                return str(message['message_time']) + ':' + message['message_text'] 
            else:
                return message['message_text']


        #=========#
        # 4 lists #
        #=========#
        error_list =   [i for i in all_messages_list if i['message_type'] == 'error']
        warning_list = [i for i in all_messages_list if i['message_type'] == 'warning']
        info_list =    [i for i in all_messages_list if i['message_type'] == 'info']
        debug_list =   [i for i in all_messages_list if i['message_type'] == 'debug']


        #=================#
        # and 1 more list #
        #=================#
        colors = {'warning' : 'magenta', 'info' : 'black'}
        warning_info_ = []
        for message in sorted(warning_list + info_list, key=lambda x: x['message_time']):
            if kw['use_psg_color']:
                warning_info_.append([   format_message(message),
                                        colors.get(message['message_type'])    ])
            else:
                warning_info_.append(format_message(message))

        error_list = map(format_message, error_list)
        warning_list = map(format_message, warning_list)
        info_list = map(format_message, info_list)
        debug_list = map(format_message, debug_list)

        return error_list, warning_list, info_list, debug_list, warning_info_

def compile_call_ref(output_filename='output/LoG_call_ref', **kw):
    ''' Compile a "5_call_reference.md" file'''

    log_obj = BESTLOG(os.path.join(cd, output_filename))
    
    main(logger=log_obj,
         main_md_file='markdown input files/5_call_reference.md',
         insert_md_section_for__class_methods=insert_md_section_for__class_methods,
         remove_repeated_sections_classmethods=remove_repeated_sections_classmethods,
         files_to_include=[],
         output_name=CALL_REFERENCE_OFILENAME,
         delete_html_comments=True)
    log_obj.save()
    return log_obj.load(**kw)

def compile_readme(output_filename='output/LoG', **kw):
    ''' Compile a "2_readme.md" file'''
    log_obj = BESTLOG(os.path.join(cd, output_filename))
    main(logger=log_obj,
         insert_md_section_for__class_methods=insert_md_section_for__class_methods,
         remove_repeated_sections_classmethods=remove_repeated_sections_classmethods,
         files_to_include=[0, 1, 2, 3],
         output_name=README_OFILENAME,
         delete_html_comments=True)
    log_obj.save()
    return log_obj.load(**kw)

def compile_all_stuff(**kw):
    '''
        Compile a "2_ and 5_" .md filess
        return output from them
    '''
    result_readme  = compile_readme(**kw)
    result_call_ref = compile_call_ref(**kw)
    return result_readme, result_call_ref


########################################
#     _____                            #
#    |  __ \                           #
#    | |__) |__  _ __  _   _ _ __      #
#    |  ___/ _ \| '_ \| | | | '_ \     #
#    | |  | (_) | |_) | |_| | |_) |    #
#    |_|   \___/| .__/ \__,_| .__/     #
#               | |         | |        #
#               |_|         |_|        #
########################################

def md2psg(target_text):
    # target = 'This is **bold** and *italic* words'
    #              V
    # sg.T('This is '), sg.T('bold', font=...bold), ...'

    # imports
    from collections import namedtuple
    spec = namedtuple('spec', 'char text'.split(' '))

    # START
    # =====
    parts = re.compile(r'([\*]{1,2})([\s\S]*?)([\*]{1,2})', flags=re.M|re.DOTALL).split(target_text)
    chuncks, skip_this = [], 0
    for index, part in enumerate(parts):
        if skip_this != 0:
            skip_this -= 1; continue

        if part not in ['*', '**']: chuncks.append(part)
        else:
            skip_this = 2
            chuncks.append(spec(part, parts[index+1]))

    font_norm = ('Mono 13 ')     # (*sg.DEFAULT_FONT, 'italic')
    font_bold = ('Mono 13 italic')     # (*sg.DEFAULT_FONT, 'italic')
    font_ita  = ('Mono 13 bold')       # (*sg.DEFAULT_FONT, 'bold')
    
    list_of_Ts = []
    for chunck in chuncks:
        if type(chunck) is str:     list_of_Ts.append(sg.T(chunck, font=font_norm, size=(len(chunck), 1), pad=(0,0)))
        elif type(chunck) is spec:
            if chunck.char == '*':  list_of_Ts.append(sg.T(chunck.text, font=font_ita, pad=(0,0), size=(len(chunck.text), 1)))
            if chunck.char == '**': list_of_Ts.append(sg.T(chunck.text, font=font_bold,  pad=(0,0), size=(len(chunck.text), 1)))
    return list_of_Ts


def mini_GUI():
    my_font = ("Helvetica", 12)
    my_font2 = ("Helvetica", 12, "bold")
    my_font3 = ("Helvetica", 15, "bold")
    my_font4 = ("Mono", 18, "bold")

    def make_tab(word):
        return [[
            sg.Column(layout=[
                [sg.T('debug', font=my_font, text_color='blue')],
                [sg.ML(size=(70-15, 15), key=f'-{word}-debug-')],
                [sg.T('error', font=my_font, text_color='red')],
                [sg.ML(size=(70-15, 15), key=f'-{word}-error-')],
            ]),
            sg.T('            '), sg.Column(layout=[
                [sg.T('warning', font=my_font2)],
                [sg.ML(size=(70-12, 15), key=f'-{word}-warning-')],
                [sg.T('info', font=my_font2)],
                [sg.ML(size=(70-12, 15), key=f'-{word}-info-')],
            ]),
            sg.Column(layout=[
                [sg.T('warning_info', font=my_font3)],
                [sg.ML(size=(110, 42-8), key=f'-{word}-warning_info-')],
            ]),
        ]]
    layout = [
        [ sg.TabGroup(  [[
                            sg.Tab('README', make_tab('README')),
                            sg.Tab('CALL_REF', make_tab('CALL_REF'))
                        ]]
                     )
        ]
    ]

    window = sg.Window('We are live! Again! --- ' + 'Completed making            {}, {}'.format(os.path.basename(README_OFILENAME), os.path.basename(CALL_REFERENCE_OFILENAME)), [
        [sg.T(size=(25,1), font=my_font, key='-compile-time-')],
        [sg.T(f'The PySimpleGUI module being processed is {sg}')],
        [  
            sg.B('Run again (F1)', key='-run-')
            ,sg.CB('show time in logs (F2)', False, key='show_time')
            ,sg.CB('Logs with Color (F3)', True, key='use_psg_color')
            ,sg.B('open call ref', key='-open_call_ref-')
            ,sg.B('open readme.txt', key='-open_readme.txt-')
            ,sg.B('open "db folder"', key='-open_db_folder-')
            ,sg.T(' '*30)
            ,sg.Col([
                    # [sg.T('output name for call_ref markdown file', key=(15,1)), sg.I(key='')],
                    [*md2psg('markdown outputFileName *FOR* **readme  **: '), sg.I(README_OFILENAME, key='md1'), sg.B('open in explorer', key='open in explorer_readme')],
                    [*md2psg('markdown outputFileName *FOR* **call ref**: '), sg.I(CALL_REFERENCE_OFILENAME, key='md2'), sg.B('open in explorer', key='open in explorer_calref')]
                ])
        ]
        ,*layout
    ], resizable=True, finalize=True, location=(0,0), return_keyboard_events = True)
    
    def update_time_in_GUI(): window['-compile-time-'](datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S.%f'))

    def update_compilation_in_psg(values):
        # get results
        result_readme, result_call_ref = compile_all_stuff(use_psg_color=values['use_psg_color'], show_time=values['show_time'])

        # DO 2_readme
        window['-README-error-']('\n'.join(result_readme[0]))
        window['-README-warning-']('\n'.join(result_readme[1]))
        window['-README-info-']('\n'.join(result_readme[2]))
        window['-README-debug-']('\n'.join(result_readme[3]))
        # /// colors warning_info
        window['-README-warning_info-'].update('')
        if values['use_psg_color']:
            for text, color in result_readme[-1]:
                window['-README-warning_info-'].print(text, text_color=color)
        else:
            window['-README-warning_info-']('\n'.join(result_readme[-1]))
        
        # DO 5_cal_ref
        window['-CALL_REF-error-']('\n'.join(result_call_ref[0]))
        window['-CALL_REF-warning-']('\n'.join(result_call_ref[1]))
        window['-CALL_REF-info-']('\n'.join(result_call_ref[2]))
        window['-CALL_REF-debug-']('\n'.join(result_call_ref[3]))
        # /// colors warning_info
        window['-CALL_REF-warning_info-'].update('')
        if values['use_psg_color']:
            for text, color in result_call_ref[-1]:
                window['-CALL_REF-warning_info-'].print(text, text_color=color)
        else:
            window['-CALL_REF-warning_info-']('\n'.join(result_call_ref[-1]))

        # ~~~~~~~~~~~~
        # GUI updating
        # ~~~~~~~~~~~~
        update_time_in_GUI()

    update_compilation_in_psg({'use_psg_color':not False, 'show_time':False})
    while True:
        event, values = window()

        # print(values)
        if event in ('Exit', None):
            APP_CONFIGS['README_FILENAME'], APP_CONFIGS['CALL_REFERENCE_FILENAME'] = window['md1'].get(), window['md2'].get()
            save_configs(APP_CONFIGS)
            break
        
        print('PSG event>', event)

        # buttons
        if event == '-run-':              update_compilation_in_psg(values)
        if event == '-open_readme.txt-':  openfile(README_OFILENAME)
        if event == '-open_call_ref-':    openfile(CALL_REFERENCE_OFILENAME)
        if event == '-open_db_folder-':   opendir(cd)
        if event == '-open_github_gallery-':   opendir(cd)
        if event == 'open in explorer_readme':    opendir(os.path.dirname(os.path.join(cd, values['md1'])))
        if event == 'open in explorer_calref':   opendir(os.path.dirname(os.path.join(cd, values['md2'])))
        # hotkeys
        if 'F1' in event: update_compilation_in_psg(values)
        if 'F2' in event: window['show_time'](not values['show_time'])
        if 'F3' in event: window['use_psg_color'](not values['use_psg_color'])

    window.close()


if __name__ == '__main__':
    mini_GUI()
    # sg.PopupScrolled('Completed making {}'.format(README_OFILENAME), ''.join(lines), size=(80,50))