�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fsql%2F'>sql</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fsql%2Fshare%2F'>share</a>/</p><hr><h3>✏️ Editing: insert_translations_into_errmsg.py</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#!/usr/bin/python3
import pdb
import re
from dataclasses import dataclass
import bisect
import argparse
################################################################################
# How this script works
# The script is mainly driven by a state machine that consumes input
# and produces output &quot;record-by-record&quot;in an iterator-like fashion. Coroutines,
# are used to consume each of the inputs only when they are needed for each
# state, assuring proper rate-matching as 3 input sources are utilized to
# determine the insertion point of the new language, and not all
# 3 inputs are consumed at the same rate.
# The following steps are performed by the script to insert translations
# of the new language into a copy of the errmsg-utf8.txt file:
# 1. Load the source file and map out the lines in a data structure
# 2. Start reading the source file line by line.
#     2.1 For each line you can be in
#          2.1.1 SEARCHING_FOR_NEXT_HEADER state
#                - In this state, we continually search the incoming 
#                  lines from the source file for a string starting
#                  with a series of capital letters (^[A-Z]+).
#                - Write each line to the output file, which is a copy
#                  of &#039;errmsg-utf8.txt&#039;.
#                - Change the state to CALCULATE_INSERT_POINT if a string matching
#                  the previous criteria is found
#                - Take the string starting with capitals and save it in
#                  the current_header variable&quot;
#          2.1.2 CALCULATE_INSERT_POINT state
#                - Go to the data structure for the source file and
#                  using te current_header as a key, read out the
#                  value part of the structure. The value part should be
#                  a list .
#                - Find the insert point for the new language
#                  error message based on the list from the previous step.
#                - Change state to PERFORM_INSERT
#          2.1.3 PERFORM_INSERT state
#                - Read the source file and copy out each line to the output
#                  file (the copy of &#039;errmsg-utf8.txt&#039;).
#                - Continue reading the source file and checking if the
#                  insert point has been reached. Once it has been reached
#                  insert the new language in the output file.
#                - Change state to SEARCHING_FOR_NEXT_HEADER 
################################################################################

class SectionList(list):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.comment_locations = []


def read_file(filename):
    &#039;&#039;&#039; A function that reads a file in one go &#039;&#039;&#039;
    with open(filename, &#039;r&#039;) as f:
        data = f.read()
    return data

def obtain_key_value_from_translation_line(translation_match, line):
    if translation_match :
        return translation_match.groups()
    else:
        return &#039;#&#039;, line # Here we assume some other line type
    #that is not a language type and its translation. Return as is with hash character as key

def map_out_source_data(data):
    &#039;&#039;&#039;
    Load the source error message file into a navigable data structure (a lists of lists
    has been chosen to ensure the source order is not disrupted)
    &#039;&#039;&#039;
    # use a regex to split the data into sections
    sections = re.split(r&#039;\n(?=[A-Z])&#039;, data)
    # create a dictionary to store the processed data
    data_dict = {}
    # process each section
    for section in sections:
        if not re.match(r&#039;^[A-Z]+&#039;, section):
            continue
        # split the section into lines
        lines = section.split(&#039;\n&#039;)
        # the title of the section is the first line
        title = lines[0].strip()
        # create a list for the key-value pairs in this section
        section_list = []
        comment_list = []
        prev_key = &#039;&#039;
        current_line_loc = 0
        # process each line (except the first one)
        for line in lines[1:]:
            # split the line into a key and a value
            print(line)
            translation_match = re.match(r&#039;\s*([a-z\-]+) \&quot;(.*)\&quot;&#039;, line)
            key, value = obtain_key_value_from_translation_line(translation_match,line)
            # add the key-value pair to the section list
            if key != &#039;#&#039;:
                section_list.append([key, value])
                prev_key = key
            elif &#039;#&#039; in value:
                # Current line in file is a comment, we want to keep
                # track of its location in the original file
                comment_list.append(current_line_loc)
            current_line_loc += 1
        section_list_with_attributes = SectionList(section_list)
        section_list_with_attributes.comment_locations = comment_list.copy()
        
        # add the section list to the main list
        data_dict[title] = section_list_with_attributes
    return data_dict

def single_file_reader(input_file_name):
    with open(input_file_name, &#039;r&#039;) as input_file:
        for line in input_file:
            yield line

def single_file_writer(output_file_name):
    with open(output_file_name, &#039;w&#039;) as output_file:
        while True:
            line = yield
            output_file.write(line)

def double_file_reader(file1, file2):
    with open(file1, &#039;r&#039;) as f1, open(file2, &#039;r&#039;) as f2:
        for line1, line2 in zip(f1, f2):
            yield (line1, line2)

def detect_language(file_name):
    with open(file_name, &#039;r&#039;) as f:
        first_line = f.readline()
        lang = first_line.split()[0]
        return lang

def detect_leading_whitespace_from_source_lang_file(file_name):
    with open(file_name, &#039;r&#039;) as f:
        first_line = f.readline()
        whitespace = first_line[:len(first_line) - len(first_line.lstrip())]
        return whitespace

@dataclass
class StateControlData:
    &quot;&quot;&quot; Class for keeping track of state machine information&quot;&quot;&quot;
    current_state: str = &#039;&#039;
    current_header: str = &#039;&#039;
    detected_dest_lang: str = &#039;&#039;
    whitespace: str = &#039;&#039;
    insert_point_index: int = 0
    stop_state_machine: bool = False
    mapped_input_data: any = None
    input_reader: any = None
    output_writer: any = None
    eng_to_new_lang_translation_mapper: any = None
    
    
def searching_for_next_header_action(state_machine_data):
    for input_line in state_machine_data.input_reader:
        if re.match(r&#039;^[A-Z]+&#039;, input_line):
            state_machine_data.current_header = input_line.strip()
            state_machine_data.current_state = &quot;CALCULATE_INSERT_POINT&quot;
            state_machine_data.output_writer.send(input_line)
            break
        state_machine_data.output_writer.send(input_line)
    else:
        state_machine_data.stop_state_machine = True
    
    return state_machine_data

def calculate_insert_point_action(state_machine_data):
    detected_dest_lang = state_machine_data.detected_dest_lang
    current_header = state_machine_data.current_header

    old_lang_list = state_machine_data.mapped_input_data[current_header]

    # Determine the spot where the new translation should fit in
    # the list of translations
    index = bisect.bisect([lang for lang, _ in old_lang_list], detected_dest_lang)
    
    state_machine_data.insert_point_index = index
    state_machine_data.current_state = &quot;PERFORM_INSERT&quot;
    
    return state_machine_data

def finding_insert_point_action(state_machine_data):
    def adjust_for_comments_occuring_before_insert_point(insert_point_index, comment_locations):
        for comment_loc in comment_locations:
            if comment_loc &lt;= insert_point_index:
                insert_point_index += 1
        return insert_point_index
            
    eng_to_new_lang_tuple = next(state_machine_data.eng_to_new_lang_translation_mapper)
    current_header = state_machine_data.current_header
    old_lang_list = state_machine_data.mapped_input_data[current_header]
    index = adjust_for_comments_occuring_before_insert_point(state_machine_data.insert_point_index, old_lang_list.comment_locations)
    detected_whitespace = state_machine_data.whitespace

    
    for i,elem in enumerate(old_lang_list):
        if index == i:
            state_machine_data.output_writer.send(detected_whitespace + eng_to_new_lang_tuple[1])
        
        input_line = next(state_machine_data.input_reader, None)
        if input_line is None:
            pdb.set_trace()
        state_machine_data.output_writer.send(input_line) 
        
    
    # New lang should be placed last
    if index &gt;= len(old_lang_list):    
        state_machine_data.output_writer.send(detected_whitespace + eng_to_new_lang_tuple[1])
        #state_machine_data.output_writer.send(&quot;\n&quot;) # The lines are stripped so we add a carriage-return

    state_machine_data.current_state = &quot;SEARCHING_FOR_NEXT_HEADER&quot;
    return state_machine_data
        

def language_inserter(data_dict, english_lang_translations_file, new_lang_translations_file):
    &#039;&#039;&#039;
    Inserts the new language into a copy of errmsg-utf8.txt, using a state machine to
    keep track of what step it is to take. Coroutines are used to keep control flow
    tractable when dealing with 4 separate files
    &#039;&#039;&#039;
    state_machine = {
        &quot;SEARCHING_FOR_NEXT_HEADER&quot; : searching_for_next_header_action,
        &quot;CALCULATE_INSERT_POINT&quot; : calculate_insert_point_action,
        &quot;PERFORM_INSERT&quot; : finding_insert_point_action
    }

    state_machine_data = StateControlData()
    
    state_machine_data.output_writer = single_file_writer(&#039;errmsg-utf8-with-new-language.txt&#039;)
    next(state_machine_data.output_writer)
    state_machine_data.input_reader = single_file_reader(&#039;errmsg-utf8.txt&#039;)
    state_machine_data.eng_to_new_lang_translation_mapper = double_file_reader(english_lang_translations_file, new_lang_translations_file)

    state_machine_data.detected_dest_lang = detect_language(new_lang_translations_file)
    state_machine_data.whitespace = detect_leading_whitespace_from_source_lang_file(english_lang_translations_file)
    state_machine_data.current_header =&#039;&#039;
    state_machine_data.current_state = &quot;SEARCHING_FOR_NEXT_HEADER&quot;
    state_machine_data.mapped_input_data = data_dict

    while not state_machine_data.stop_state_machine:
        current_state = state_machine_data.current_state
        state_machine_data = state_machine[current_state](state_machine_data)
        

def main():
    &#039;&#039;&#039; main function &#039;&#039;&#039;
    parser = argparse.ArgumentParser(description=&#039;&#039;&#039;Given errmsg-utf8.txt, 
    an english language file extracted from errmsg-utf8.txt and another
    file with translations into a new language from the english language
    file, reinsert the new language translations into their correct
    positions in a copy of errmsg-utf8.txt.&#039;&#039;&#039;)
    parser.add_argument(&#039;errmsg_file&#039;, type=str, help=&#039;Path to errmsg-utf8.txt&#039;)
    parser.add_argument(&#039;english_lang_translations_file&#039;, type=str, help=&#039;Path to English lang translations file&#039;)
    parser.add_argument(&#039;new_lang_translations_file&#039;, type=str, help=&#039;Path to new lang translations file&#039;)

    args = parser.parse_args()
    errmsg_file = args.errmsg_file
    english_lang_translations_file = args.english_lang_translations_file
    new_lang_translations_file = args.new_lang_translations_file
    
    data = read_file(errmsg_file)
    data_dict = map_out_source_data(data)
    print(&#039;Original file errmsg-utf8.txt has been successfully mapped into memory.&#039;)
    print(&#039;&#039;&#039;Now starting insertion process into errmsg-utf8-with-new-language.txt which is
 a copy of errmsg-utf8.txt&#039;&#039;&#039;)

    # In case you want to hard code the language source files, uncomment
    # the below two lines, set the new language file name and disable
    # argument parsing.
    #english_lang_translations_file = &#039;all_english_text_in_errmsg-utf8.txt&#039;
    #new_lang_translations_file = &#039;all_swahili_text_in_errmsg-utf8.txt&#039;
    language_inserter(data_dict, english_lang_translations_file, new_lang_translations_file)
    print(&quot;Insertion of new language translations into errmsg-utf8-with-new-language.txt is done&quot;)

# call the main function
if __name__ == &quot;__main__&quot;:
    main()



</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fsql%2Fshare'>🔙 Back</a></p>