logic_to_latex.py

from logicDB import rules
from logicDB import conversions
import re

# If in test mode, file is already selected vs user entering file name
# (e.g. terminal interface)
# DEBUG
test_mode = True

'''
Known problems:
    - The program changes 'v's in annotations to ' \vee '
          FIX: just change the LaTex back to 'v'
    - Cannot have spaces in sentences
          FIX: delete spaces in sentences in text file prior to import
    - Need to have space between annotations and numbers
    - Cannot have empty assumption set (e.g. axioms)
          FIX: add a character place holder (e.g. 'x') and remove it later
'''


# Description: If test mode is False, this will ask user for file name and loop
#              until valid file is given
# Input: none, user input
# Output: the opened file - infile
def get_file():
    flag = True
    while flag is True:
        try:
            file = input('Enter the name of the txt file: ')
            infile = open(file, 'r')
            flag = False
        except Exception:
            flag = True
    return infile


# Description: Creates a new 2D list with each element split
# Input: content_list - a 1D list with *correct* spacing
# Output: split list
def split_list(content_list):
    # Split elements in list
    new_list = []
    for i in range(len(content_list)):
        new_list.append(re.findall(r'([^\s]+)', content_list[i]))

    return new_list


# Description: Prints LaTex formatting to the console
# Input: content_list
# Output: none, output to screen
# TODO : this could be simplified a lot
def latex_print(content_list):
    assumption_set = []
    line_number = []
    sentence = []
    annotation_set = []
    annotation = []

    for i in range(len(content_list)):
        assumption_set.append(content_list[i][0])
        line_number.append(content_list[i][1])
        sentence.append(content_list[i][2])

        # Some rows have 5 columns due to annotation sets
        # TODO : this seems like a poor way to handle this
        if len(content_list[i]) == 5:
            annotation_set.append(content_list[i][3])
            annotation.append(content_list[i][4])
        else:
            annotation_set.append('')
            annotation.append(content_list[i][3])

        # TODO : Prints to console, could return or save to file in future
        print('{} & {} ${}$ & {} & {}\\\\' .format(assumption_set[i],
                                                   line_number[i],
                                                   sentence[i],
                                                   annotation_set[i],
                                                   annotation[i]))


# Description: Swaps symbols for sentence column from logic to LaTex
# Input: conversions list, content list
# Output: updated list
# TODO(1) : only want this to apply to content_list[i][2]
# BUG
def sentence_swap(conversions, content_list):
    for i in range(len(content_list)):
        for j in range(len(conversions)):
                content_list[i] = [x.replace(conversions[j][2], conversions[j][1]) for x in content_list[i]]

    return content_list


# Description: Swaps annotation symbols for words
# Input: rules list, content list
# Output: updated list
# TODO(2) : only want this to apply to content_list[i][4]
# TODO : could use regex to parse two spaces as boundary for sentences
# BUG
def assumption_swap(rules, content_list):
    for i in range(len(content_list)):
        for j in range(len(rules)):
            content_list[i] = [x.replace(rules[j][0], rules[j][2]) for x in content_list[i]]

    return content_list


# Description: Performs swaps for first line
# Input: conversions list, line to be converted
# Output: converted line
def swap(conversions, logic):
    logic = logic.replace(' ', '')
    logic = logic.strip()
    for i in range(len(conversions)):
        logic = logic.replace(conversions[i][2], conversions[i][1])
    return logic


# Description: Prints converted line
# Input: converted line
# Output: none, screen output
def latex_print_line(logic):
    print('${}$\\\\' .format(logic))


def main():

    # DEBUG
    if test_mode is True:
        infile = open('logic.txt', 'r')
    else:
        infile = get_file()

    # Create list and close file
    content_list = infile.readlines()
    infile.close()
    first_line = content_list[0]
    del content_list[0]

    # Split elements in list
    content_list = split_list(content_list)

    # DEBUG - 1
    if test_mode is True:
        print('-' * 20)
        print('(1) [Assumption set, Line Number, Sentence, Annotation]')
        print('-' * 20)
        # [Assumption set, Line Number, Sentence, Annotation]
        for i in content_list:
            print(i)

    # DEBUG - 2
    if test_mode is True:
        print('-' * 20)
        print('(2) Initial LaTex print before any swaps')
        print('-' * 20)
        latex_print(content_list)

    content_list = assumption_swap(rules, content_list)

    # DEBUG - 3
    if test_mode is True:
        print('-' * 20)
        print('(3) LaTex print after Annotations are swapped')
        print('-' * 20)
        latex_print(content_list)

    content_list = sentence_swap(conversions, content_list)

    logic = swap(conversions, first_line)

    # DEBUG - 4
    if test_mode is True:
        print('-' * 20)
        print('(4) LaTex print after sentences are swapped (final result)')
        print('-' * 20)
        latex_print_line(logic)
        print('')
        print('\\begin{tabular}{llll}')
        # print final answer
        latex_print(content_list)
        print('\\end{tabular}')
    else:
        latex_print_line(logic)
        print('')
        print('\\begin{tabular}{llll}')
        # print final answer
        latex_print(content_list)
        print('\\end{tabular}')


if __name__ == "__main__":
    main()